@google/gemini-cli-a2a-server 0.18.3 → 0.18.4

package/dist/a2a-server.mjs

@@ -303410,6 +303410,11 @@ var FatalAuthenticationError = class extends FatalError {
     super(message, 41);
   }
 };
+var FatalCancellationError = class extends FatalError {
+  constructor(message) {
+    super(message, 130);
+  }
+};
 var ForbiddenError = class extends Error {
 };
 var UnauthorizedError = class extends Error {
@@ -304155,7 +304160,63 @@ init_base_token_storage();
 var DEFAULT_SERVICE_NAME = "gemini-cli-oauth";
 var FORCE_ENCRYPTED_FILE_ENV_VAR = "GEMINI_FORCE_ENCRYPTED_FILE_STORAGE";
 
+// packages/core/dist/src/utils/stdio.js
+init_events();
+var originalStdoutWrite = process.stdout.write.bind(process.stdout);
+var originalStderrWrite = process.stderr.write.bind(process.stderr);
+function writeToStdout(...args2) {
+  return originalStdoutWrite(...args2);
+}
+function writeToStderr(...args2) {
+  return originalStderrWrite(...args2);
+}
+function createInkStdio() {
+  const inkStdout = new Proxy(process.stdout, {
+    get(target, prop, receiver) {
+      if (prop === "write") {
+        return writeToStdout;
+      }
+      const value = Reflect.get(target, prop, receiver);
+      if (typeof value === "function") {
+        return value.bind(target);
+      }
+      return value;
+    }
+  });
+  const inkStderr = new Proxy(process.stderr, {
+    get(target, prop, receiver) {
+      if (prop === "write") {
+        return writeToStderr;
+      }
+      const value = Reflect.get(target, prop, receiver);
+      if (typeof value === "function") {
+        return value.bind(target);
+      }
+      return value;
+    }
+  });
+  return { stdout: inkStdout, stderr: inkStderr };
+}
+
+// packages/core/dist/src/utils/terminal.js
+function disableMouseEvents() {
+  writeToStdout("\x1B[?1006l\x1B[?1002l");
+}
+function disableKittyKeyboardProtocol() {
+  writeToStdout("\x1B[<u");
+}
+function enableLineWrapping() {
+  writeToStdout("\x1B[?7h");
+}
+function enterAlternateScreen() {
+  writeToStdout("\x1B[?1049h");
+}
+function exitAlternateScreen() {
+  writeToStdout("\x1B[?1049l");
+}
+
 // packages/core/dist/src/code_assist/oauth2.js
+init_events();
 var userAccountManager = new UserAccountManager();
 var OAUTH_CLIENT_ID = "681255809395-oo8ft2oprdrnp9e3aqf6av3hmdib135j.apps.googleusercontent.com";
 var OAUTH_CLIENT_SECRET = "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";
@@ -304246,18 +304307,31 @@ async function initOauthClient(authType, config3) {
   if (config3.isBrowserLaunchSuppressed()) {
     let success = false;
     const maxRetries = 2;
-    for (let i4 = 0; !success && i4 < maxRetries; i4++) {
-      success = await authWithUserCode(client);
-      if (!success) {
-        debugLogger.error("\nFailed to authenticate with user code.", i4 === maxRetries - 1 ? "" : "Retrying...\n");
+    enterAlternateScreen();
+    writeToStdout("\x1B[2J\x1B[H");
+    disableMouseEvents();
+    disableKittyKeyboardProtocol();
+    enableLineWrapping();
+    try {
+      for (let i4 = 0; !success && i4 < maxRetries; i4++) {
+        success = await authWithUserCode(client);
+        if (!success) {
+          writeToStderr("\nFailed to authenticate with user code." + (i4 === maxRetries - 1 ? "" : " Retrying...\n"));
+        }
       }
+    } finally {
+      exitAlternateScreen();
+      coreEvents.emit(CoreEvent.ExternalEditorClosed);
     }
     if (!success) {
+      writeToStderr("Failed to authenticate with user code.\n");
       throw new FatalAuthenticationError("Failed to authenticate with user code.");
     }
   } else {
     const webLogin = await authWithWeb(client);
-    debugLogger.log(`
+    coreEvents.emit(CoreEvent.UserFeedback, {
+      severity: "info",
+      message: `
 
 Code Assist login required.
 Attempting to open authentication page in your browser.
@@ -304265,19 +304339,30 @@ Otherwise navigate to:
 
 ${webLogin.authUrl}
 
-`);
+
+`
+    });
     try {
       const childProcess2 = await open_default(webLogin.authUrl);
       childProcess2.on("error", (error2) => {
-        debugLogger.error(`Failed to open browser with error:`, getErrorMessage(error2), `
-Please try running again with NO_BROWSER=true set.`);
+        coreEvents.emit(CoreEvent.UserFeedback, {
+          severity: "error",
+          message: `Failed to open browser with error: ${getErrorMessage(error2)}
+Please try running again with NO_BROWSER=true set.`
+        });
       });
     } catch (err2) {
-      debugLogger.error(`Failed to open browser with error:`, getErrorMessage(err2), `
-Please try running again with NO_BROWSER=true set.`);
+      coreEvents.emit(CoreEvent.UserFeedback, {
+        severity: "error",
+        message: `Failed to open browser with error: ${getErrorMessage(err2)}
+Please try running again with NO_BROWSER=true set.`
+      });
       throw new FatalAuthenticationError(`Failed to open browser: ${getErrorMessage(err2)}`);
     }
-    debugLogger.log("Waiting for authentication...");
+    coreEvents.emit(CoreEvent.UserFeedback, {
+      severity: "info",
+      message: "Waiting for authentication...\n"
+    });
     const authTimeout = 5 * 60 * 1e3;
     const timeoutPromise = new Promise((_, reject) => {
       setTimeout(() => {
@@ -304285,6 +304370,10 @@ Please try running again with NO_BROWSER=true set.`);
       }, authTimeout);
     });
     await Promise.race([webLogin.loginCompletePromise, timeoutPromise]);
+    coreEvents.emit(CoreEvent.UserFeedback, {
+      severity: "info",
+      message: "Authentication succeeded\n"
+    });
   }
   return client;
 }
@@ -304295,47 +304384,56 @@ async function getOauthClient(authType, config3) {
   return oauthClientPromises.get(authType);
 }
 async function authWithUserCode(client) {
-  const redirectUri = "https://codeassist.google.com/authcode";
-  const codeVerifier = await client.generateCodeVerifierAsync();
-  const state = crypto13.randomBytes(32).toString("hex");
-  const authUrl = client.generateAuthUrl({
-    redirect_uri: redirectUri,
-    access_type: "offline",
-    scope: OAUTH_SCOPE,
-    code_challenge_method: import_google_auth_library8.CodeChallengeMethod.S256,
-    code_challenge: codeVerifier.codeChallenge,
-    state
-  });
-  debugLogger.log("Please visit the following URL to authorize the application:");
-  debugLogger.log("");
-  debugLogger.log(authUrl);
-  debugLogger.log("");
-  const code2 = await new Promise((resolve14) => {
-    const rl = readline.createInterface({
-      input: process.stdin,
-      output: process.stdout
-    });
-    rl.question("Enter the authorization code: ", (code3) => {
-      rl.close();
-      resolve14(code3.trim());
-    });
-  });
-  if (!code2) {
-    debugLogger.error("Authorization code is required.");
-    return false;
-  }
   try {
-    const { tokens } = await client.getToken({
-      code: code2,
-      codeVerifier: codeVerifier.codeVerifier,
-      redirect_uri: redirectUri
+    const redirectUri = "https://codeassist.google.com/authcode";
+    const codeVerifier = await client.generateCodeVerifierAsync();
+    const state = crypto13.randomBytes(32).toString("hex");
+    const authUrl = client.generateAuthUrl({
+      redirect_uri: redirectUri,
+      access_type: "offline",
+      scope: OAUTH_SCOPE,
+      code_challenge_method: import_google_auth_library8.CodeChallengeMethod.S256,
+      code_challenge: codeVerifier.codeChallenge,
+      state
     });
-    client.setCredentials(tokens);
-  } catch (error2) {
-    debugLogger.error("Failed to authenticate with authorization code:", getErrorMessage(error2));
+    writeToStdout("Please visit the following URL to authorize the application:\n\n" + authUrl + "\n\n");
+    const code2 = await new Promise((resolve14, _) => {
+      const rl = readline.createInterface({
+        input: process.stdin,
+        output: createInkStdio().stdout,
+        terminal: true
+      });
+      rl.question("Enter the authorization code: ", (code3) => {
+        rl.close();
+        resolve14(code3.trim());
+      });
+    });
+    if (!code2) {
+      writeToStderr("Authorization code is required.\n");
+      debugLogger.error("Authorization code is required.");
+      return false;
+    }
+    try {
+      const { tokens } = await client.getToken({
+        code: code2,
+        codeVerifier: codeVerifier.codeVerifier,
+        redirect_uri: redirectUri
+      });
+      client.setCredentials(tokens);
+    } catch (error2) {
+      writeToStderr("Failed to authenticate with authorization code:" + getErrorMessage(error2) + "\n");
+      debugLogger.error("Failed to authenticate with authorization code:", getErrorMessage(error2));
+      return false;
+    }
+    return true;
+  } catch (err2) {
+    if (err2 instanceof FatalCancellationError) {
+      throw err2;
+    }
+    writeToStderr("Failed to authenticate with user code:" + getErrorMessage(err2) + "\n");
+    debugLogger.error("Failed to authenticate with user code:", getErrorMessage(err2));
     return false;
   }
-  return true;
 }
 async function authWithWeb(client) {
   const port = await getAvailablePort();
@@ -307590,8 +307688,8 @@ var Float64Vector = import_vector.default.Float64Vector;
 var PointerVector = import_vector.default.PointerVector;
 
 // packages/core/dist/src/generated/git-commit.js
-var GIT_COMMIT_INFO = "4b19a8338";
-var CLI_VERSION = "0.18.3";
+var GIT_COMMIT_INFO = "2e8d7831c";
+var CLI_VERSION = "0.18.4";
 
 // packages/core/dist/src/ide/detect-ide.js
 var IDE_DEFINITIONS = {
@@ -310450,7 +310548,7 @@ async function createContentGenerator(config3, gcConfig, sessionId2) {
     if (gcConfig.fakeResponses) {
       return FakeContentGenerator.fromFile(gcConfig.fakeResponses);
     }
-    const version4 = "0.18.3";
+    const version4 = "0.18.4";
     const userAgent = `GeminiCLI/${version4} (${process.platform}; ${process.arch})`;
     const baseHeaders = {
       "User-Agent": userAgent
@@ -371734,7 +371832,7 @@ async function getClientMetadata() {
     clientMetadataPromise = (async () => ({
       ideName: "IDE_UNSPECIFIED",
       pluginType: "GEMINI",
-      ideVersion: "0.18.3",
+      ideVersion: "0.18.4",
       platform: getPlatform(),
       updateChannel: await getReleaseChannel(__dirname5)
     }))();