Refactor: Eliminate no-unsafe-return suppressions via strict type validation

packages/cli/src/commands/extensions/utils.ts

@@ -47,8 +47,7 @@ const defaultRequestConfirmation: RequestConfirmationCallback = async (
     message,
     initial: false,
   });
-  // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-  return response.confirm;
+  return typeof response.confirm === 'boolean' ? response.confirm : false;
 };
 
 export async function getExtensionManager() {

packages/cli/src/config/extensionRegistryClient.ts

@@ -82,9 +82,8 @@ export class ExtensionRegistryClient {
       fuzzy: true,
     });
     // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-    const results = await fzf.find(query);
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-    return results.map((r: { item: RegistryExtension }) => r.item);
+    const results: Array<{ item: RegistryExtension }> = await fzf.find(query);
+    return results.map((r) => r.item);
   }
 
   async getExtension(id: string): Promise<RegistryExtension | undefined> {

packages/cli/src/config/extensions/extensionEnablement.ts

@@ -8,6 +8,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { coreEvents, type GeminiCLIExtension } from '@google/gemini-cli-core';
 import { ExtensionStorage } from './storage.js';
+import { z } from 'zod';
 
 export interface ExtensionEnablementConfig {
   overrides: string[];
@@ -179,8 +180,12 @@ export class ExtensionEnablementManager {
   readConfig(): AllExtensionsEnablementConfig {
     try {
       const content = fs.readFileSync(this.configFilePath, 'utf-8');
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-      return JSON.parse(content);
+      const parsed: unknown = JSON.parse(content);
+      const schema = z.record(
+        z.string(),
+        z.object({ overrides: z.array(z.string()) }),
+      );
+      return schema.parse(parsed);
     } catch (error) {
       if (
         error instanceof Error &&

packages/cli/src/config/extensions/extensionSettings.ts

@@ -165,8 +165,7 @@ export async function promptForSetting(
     name: 'value',
     message: `${setting.name}\n${setting.description}`,
   });
-  // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-  return response.value;
+  return typeof response.value === 'string' ? response.value : '';
 }
 
 export async function getScopedEnvContents(

packages/cli/src/config/extensions/variables.ts

@@ -57,8 +57,7 @@ export function recursivelyHydrateStrings<T>(
   }
   if (Array.isArray(obj)) {
     // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-    return obj.map((item) =>
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+    return (obj as unknown[]).map((item) =>
       recursivelyHydrateStrings(item, values),
     ) as unknown as T;
   }

packages/cli/src/test-utils/mockCommandContext.ts

@@ -121,6 +121,11 @@ export const createMockCommandContext = (
     return output;
   };
 
-  // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-  return merge(defaultMocks, overrides);
+  const merged: unknown = merge(defaultMocks, overrides);
+  const isCommandContext = (val: unknown): val is CommandContext =>
+    typeof val === 'object' && val !== null;
+  if (isCommandContext(merged)) {
+    return merged;
+  }
+  throw new Error('Unreachable');
 };

packages/cli/src/test-utils/render.tsx

@@ -715,8 +715,7 @@ export const renderWithProviders = (
         if (prop === 'getUseAlternateBuffer') {
           return () => useAlternateBuffer;
         }
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-        return Reflect.get(target, prop, receiver);
+        return Reflect.get(target, prop, receiver) as unknown;
       },
     });
   }

packages/cli/src/ui/hooks/useAtCompletion.ts

@@ -167,13 +167,13 @@ async function searchResourceCandidates(
     selector: (candidate: ResourceSuggestionCandidate) => candidate.searchKey,
   });
   // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-  const results = await fzf.find(normalizedPattern, {
-    limit: MAX_SUGGESTIONS_TO_SHOW * 3,
-  });
-  // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-  return results.map(
-    (result: { item: ResourceSuggestionCandidate }) => result.item.suggestion,
+  const results: Array<{ item: ResourceSuggestionCandidate }> = await fzf.find(
+    normalizedPattern,
+    {
+      limit: MAX_SUGGESTIONS_TO_SHOW * 3,
+    },
   );
+  return results.map((result) => result.item.suggestion);
 }
 
 async function searchAgentCandidates(
@@ -191,11 +191,13 @@ async function searchAgentCandidates(
     selector: (s: Suggestion) => s.label,
   });
   // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-  const results = await fzf.find(normalizedPattern, {
-    limit: MAX_SUGGESTIONS_TO_SHOW,
-  });
-  // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-  return results.map((r: { item: Suggestion }) => r.item);
+  const results: Array<{ item: Suggestion }> = await fzf.find(
+    normalizedPattern,
+    {
+      limit: MAX_SUGGESTIONS_TO_SHOW,
+    },
+  );
+  return results.map((r) => r.item);
 }
 
 export function useAtCompletion(props: UseAtCompletionProps): void {

packages/cli/src/ui/utils/TableRenderer.tsx

@@ -174,7 +174,10 @@ export const TableRenderer: React.FC<TableRendererProps> = ({
     }
 
     // --- Pre-wrap and Optimize Widths ---
-    const actualColumnWidths = new Array(numColumns).fill(0);
+    const actualColumnWidths: number[] = [];
+    for (let i = 0; i < numColumns; i++) {
+      actualColumnWidths.push(0);
+    }
 
     const wrapAndProcessRow = (row: StyledChar[][]) => {
       const rowResult: ProcessedLine[][] = [];
@@ -208,11 +211,7 @@ export const TableRenderer: React.FC<TableRendererProps> = ({
     const wrappedRows = styledRows.map((row) => wrapAndProcessRow(row));
 
     // Use the TIGHTEST widths that fit the wrapped content + padding
-    const adjustedWidths = actualColumnWidths.map(
-      (w) =>
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-        w + COLUMN_PADDING,
-    );
+    const adjustedWidths = actualColumnWidths.map((w) => w + COLUMN_PADDING);
 
     return { wrappedHeaders, wrappedRows, adjustedWidths };
   }, [styledHeaders, styledRows, terminalWidth]);
@@ -263,7 +262,6 @@ export const TableRenderer: React.FC<TableRendererProps> = ({
     isHeader = false,
   ): React.ReactNode => {
     const renderedCells = cells.map((cell, index) => {
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
       const width = adjustedWidths[index] || 0;
       return renderCell(cell, width, isHeader);
     });

packages/cli/src/utils/envVarResolver.ts

@@ -91,18 +91,20 @@ function resolveEnvVarsInObjectInternal<T>(
     // Check for circular reference
     if (visited.has(obj)) {
       // Return a shallow copy to break the cycle
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-      return [...obj] as unknown as T;
+      const copy: unknown = [...obj];
+      const isTArray = (val: unknown): val is T => Array.isArray(val);
+      if (isTArray(copy)) return copy;
+      throw new Error('Unreachable');
     }
 
     visited.add(obj);
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-    const result = obj.map((item) =>
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+    const mapped: unknown = obj.map((item: unknown) =>
       resolveEnvVarsInObjectInternal(item, visited, customEnv),
-    ) as unknown as T;
+    );
     visited.delete(obj);
-    return result;
+    const isTArray = (val: unknown): val is T => Array.isArray(val);
+    if (isTArray(mapped)) return mapped;
+    throw new Error('Unreachable');
   }
 
   if (typeof obj === 'object') {

packages/cli/src/utils/gitUtils.ts

@@ -83,8 +83,7 @@ export const getLatestGitHubRelease = async (
     if (!releaseTag) {
       throw new Error(`Response did not include tag_name field`);
     }
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-    return releaseTag;
+    return typeof releaseTag === 'string' ? releaseTag : '';
   } catch (_error) {
     debugLogger.debug(
       `Failed to determine latest run-gemini-cli release:`,

packages/cli/src/utils/jsonoutput.ts

@@ -29,8 +29,7 @@ export function tryParseJSON(input: string): object | null {
   if (!checkInput(input)) return null;
   const trimmed = input.trim();
   try {
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-    const parsed = JSON.parse(trimmed);
+    const parsed: unknown = JSON.parse(trimmed);
     if (parsed === null || typeof parsed !== 'object') {
       return null;
     }
@@ -40,7 +39,6 @@ export function tryParseJSON(input: string): object | null {
 
     if (!Array.isArray(parsed) && Object.keys(parsed).length === 0) return null;
 
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
     return parsed;
   } catch (_err) {
     return null;

packages/cli/src/utils/settingsUtils.ts

@@ -371,10 +371,8 @@ export function setPendingSettingValue(
   pendingSettings: Settings,
 ): Settings {
   const path = key.split('.');
-  // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-  const newSettings = JSON.parse(JSON.stringify(pendingSettings));
-  setNestedValue(newSettings, path, value);
-  // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+  const newSettings = structuredClone(pendingSettings);
+  setNestedValue(newSettings as Record<string, unknown>, path, value);
   return newSettings;
 }
 

packages/cli/src/zed-integration/fileSystemService.ts

@@ -29,8 +29,8 @@ export class AcpFileSystemService implements FileSystemService {
       sessionId: this.sessionId,
     });
 
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-    return response.content;
+    const content: unknown = response.content;
+    return typeof content === 'string' ? content : '';
   }
 
   async writeTextFile(filePath: string, content: string): Promise<void> {

packages/core/src/code_assist/oauth2.ts

@@ -639,8 +639,13 @@ async function fetchCachedCredentials(): Promise<
   for (const keyFile of pathsToTry) {
     try {
       const keyFileString = await fs.readFile(keyFile, 'utf-8');
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-      return JSON.parse(keyFileString);
+      const parsed: unknown = JSON.parse(keyFileString);
+      const isOAuthCreds = (val: unknown): val is Credentials | JWTInput =>
+        typeof val === 'object' && val !== null;
+      if (isOAuthCreds(parsed)) {
+        return parsed;
+      }
+      throw new Error('Invalid credentials format');
     } catch (error) {
       // Log specific error for debugging, but continue trying other paths
       debugLogger.debug(

packages/core/src/config/projectRegistry.ts

@@ -9,6 +9,7 @@ import * as path from 'node:path';
 import * as os from 'node:os';
 import { lock } from 'proper-lockfile';
 import { debugLogger } from '../utils/debugLogger.js';
+import { z } from 'zod';
 
 export interface RegistryData {
   projects: Record<string, string>;
@@ -59,8 +60,11 @@ export class ProjectRegistry {
 
     try {
       const content = await fs.promises.readFile(this.registryPath, 'utf8');
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-      return JSON.parse(content);
+      const parsed: unknown = JSON.parse(content);
+      const schema = z.object({
+        projects: z.record(z.string(), z.string()),
+      });
+      return schema.parse(parsed);
     } catch (e) {
       debugLogger.debug('Failed to load registry: ', e);
       // If the registry is corrupted, we'll start fresh to avoid blocking the CLI

packages/core/src/core/baseLlmClient.ts

@@ -162,10 +162,15 @@ export class BaseLlmClient {
     );
 
     // If we are here, the content is valid (not empty and parsable).
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-    return JSON.parse(
+    const parsed: unknown = JSON.parse(
       this.cleanJsonResponse(getResponseText(result)!.trim(), model),
     );
+    const isRecord = (val: unknown): val is Record<string, unknown> =>
+      typeof val === 'object' && val !== null && !Array.isArray(val);
+    if (isRecord(parsed)) {
+      return parsed;
+    }
+    throw new Error('Invalid JSON response format from LLM');
   }
 
   async generateEmbedding(texts: string[]): Promise<number[][]> {

packages/core/src/core/fakeContentGenerator.ts

@@ -84,11 +84,12 @@ export class FakeContentGenerator implements ContentGenerator {
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     role: LlmRole,
   ): Promise<GenerateContentResponse> {
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-    return Object.setPrototypeOf(
-      this.getNextResponse('generateContent', request),
-      GenerateContentResponse.prototype,
-    );
+    const response: unknown = this.getNextResponse('generateContent', request);
+    Object.setPrototypeOf(response, GenerateContentResponse.prototype);
+    if (response instanceof GenerateContentResponse) {
+      return response;
+    }
+    throw new Error('Failed to create GenerateContentResponse');
   }
 
   async generateContentStream(
@@ -118,10 +119,11 @@ export class FakeContentGenerator implements ContentGenerator {
   async embedContent(
     request: EmbedContentParameters,
   ): Promise<EmbedContentResponse> {
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-    return Object.setPrototypeOf(
-      this.getNextResponse('embedContent', request),
-      EmbedContentResponse.prototype,
-    );
+    const response: unknown = this.getNextResponse('embedContent', request);
+    Object.setPrototypeOf(response, EmbedContentResponse.prototype);
+    if (response instanceof EmbedContentResponse) {
+      return response;
+    }
+    throw new Error('Failed to create EmbedContentResponse');
   }
 }

packages/core/src/core/localLiteRtLmClient.ts

@@ -83,8 +83,13 @@ export class LocalLiteRtLmClient {
         );
       }
 
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-      return JSON.parse(result.text);
+      const parsed: unknown = JSON.parse(result.text);
+      const isRecord = (val: unknown): val is Record<string, unknown> =>
+        typeof val === 'object' && val !== null && !Array.isArray(val);
+      if (isRecord(parsed)) {
+        return parsed;
+      }
+      throw new Error('Invalid JSON response format from Local LLM');
     } catch (error) {
       debugLogger.error(
         `[LocalLiteRtLmClient] Failed to generate content:`,

packages/core/src/ide/ide-client.ts

@@ -347,9 +347,11 @@ export class IdeClient {
         try {
           // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
           const parsedJson = JSON.parse(textPart.text);
-          if (parsedJson && typeof parsedJson.content === 'string') {
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-            return parsedJson.content;
+          if (parsedJson) {
+            const content: unknown = parsedJson.content;
+            if (typeof content === 'string') {
+              return content;
+            }
           }
           if (parsedJson && parsedJson.content === null) {
             return undefined;