ISSUE_251107_coaia_tash_fetch.md

[jgwill]

Issue: coaia tash and coaia fetch commands failing with Redis authentication error

Problem Description

The coaia tash and coaia fetch commands are currently failing to execute successfully, returning an "invalid username-password pair or user is disabled" error. This occurs even when no .env file is explicitly present in the current working directory, suggesting a potential misconfiguration or incorrect handling of Redis connection parameters.

Observed Behavior

When attempting to use coaia tash (e.g., coaia tash TMP -F README.md -T 33) or coaia fetch <key>, the following error message is displayed:

invalid username-password pair or user is disabled
Key: TMP  was just saved to memory.

Despite the message indicating the key was saved, subsequent coaia fetch commands for the same key also fail with the same authentication error. This indicates that the operation is not completing successfully due to a Redis authentication issue.

Expected Behavior

1. The coaia tash and coaia fetch commands should successfully interact with the configured Redis instance.
2. The commands should correctly prioritize environment variables for Redis connection, specifically UPSTASH_REDIS_REST_URL and UPSTASH_REDIS_REST_TOKEN.
3. If a .env file exists in the current working directory (/src/coaiapy/), these variables should be read from it and used for Redis authentication.
4. If no .env file is present, the commands should fall back to other configured methods (e.g., ~/.coaia.json or other global configurations) without authentication errors.

Reproduction Steps

1. Ensure no .env file is present in /src/coaiapy/.
2. Execute coaia tash TMP -F README.md -T 33.
3. Observe the "invalid username-password pair or user is disabled" error.
4. Execute coaia fetch TMP.
5. Observe the same authentication error.

Relevant Environment Variables

The following environment variables are critical for Redis connection and should be correctly processed by the coaia tool:

• UPSTASH_REDIS_REST_URL
• UPSTASH_REDIS_REST_TOKEN

These variables should be looked for in the .env file within the current working directory (/src/coaiapy/) first.

Suggested Solution/Investigation Areas for Copilot Agents

Copilot agents should investigate the following:

1. Environment Variable Loading: Verify how coaia loads and prioritizes environment variables, especially from .env files. Ensure that python-dotenv or a similar mechanism is correctly implemented and functioning.
2. Redis Client Configuration: Examine the coaia codebase to understand how the Redis client is initialized and how the UPSTASH_REDIS_REST_URL and UPSTASH_REDIS_REST_TOKEN are passed to it. There might be an issue with how these credentials are being formatted or used during the connection attempt.
3. Fallback Mechanism: Confirm that the fallback logic for Redis configuration (when .env variables are not present) is correctly implemented and does not lead to authentication failures.
4. Error Handling: Improve error messaging to provide more specific details about why the authentication failed (e.g., which credential was invalid, which configuration source was used).
5. Testing: Implement unit and integration tests to ensure robust handling of Redis connection parameters and environment variables under various scenarios (e.g., .env present, .env absent, invalid credentials).

[jgwill]

Complementary Analysis: Adjustments for coaia tash and coaia fetch Redis Issue

Analysis of Likely Root Cause

The primary issue appears to stem from an incomplete or incorrect mechanism for loading and prioritizing Redis connection credentials, particularly the UPSTASH_REDIS_REST_URL and UPSTASH_REDIS_REST_TOKEN environment variables. The error message "invalid username-password pair or user is disabled" strongly suggests that the Redis client is either not receiving the correct credentials or is attempting to connect with default/empty credentials.

Given the user's expectation that .env files should be prioritized, it's highly probable that the coaiapy application is not correctly loading variables from a local .env file, or that the loaded variables are not being properly injected into the Redis client's configuration.

Proposed Adjustments and Guidance

1. Robust .env File Loading

Adjustment: Implement python-dotenv for explicit and reliable loading of environment variables from a .env file.

Guidance:

• Installation: Ensure python-dotenv is listed in requirements.txt and installed.
• Implementation: At the very beginning of the coaiapy application's entry point (e.g., coaiacli.py or coaiamodule.py if it's the main entry), add the following:

  from dotenv import load_dotenv
  import os
  
  # Load environment variables from .env file
  load_dotenv()

• This ensures that any UPSTASH_REDIS_REST_URL and UPSTASH_REDIS_REST_TOKEN defined in a .env file in the current working directory will be loaded into os.environ.

2. Redis Client Initialization with Environment Variables

Adjustment: Modify the Redis client initialization logic to explicitly retrieve credentials from os.environ.

Guidance:

• Location: Identify where the Redis client (likely redis.Redis or a similar client) is instantiated within coaiapy (e.g., in cofuse.py or a dedicated config.py/redis_client.py module).
• Credential Retrieval: Before initializing the Redis client, retrieve the URL and token:

  import os
  import redis # Assuming redis-py is used
  
  redis_url = os.getenv('UPSTASH_REDIS_REST_URL')
  redis_token = os.getenv('UPSTASH_REDIS_REST_TOKEN')
  
  if not redis_url or not redis_token:
      # Handle cases where credentials are not found
      # This could involve falling back to a default config, 
      # raising an error, or logging a warning.
      # For now, let's assume they *should* be present.
      print("Warning: Redis credentials (UPSTASH_REDIS_REST_URL or UPSTASH_REDIS_REST_TOKEN) not found in environment.")
      # Potentially raise an exception or use a different connection method
      # For example, if there's a local Redis or a different config file.
  
  # Example of Redis client initialization (adjust based on actual client library)
  # If using redis-py with a URL that includes auth:
  # r = redis.from_url(redis_url)
  
  # If using separate host/port/password:
  # Parse redis_url to extract host, port, password if not using from_url
  # For Upstash, the URL typically includes the password.
  # Example for Upstash Redis REST API (which might not use standard redis-py directly for REST)
  # If coaia uses a custom HTTP client for Upstash REST, ensure headers/body include the token.
  # If it's a standard Redis connection, the URL should be parsed correctly.
  
  # Assuming a standard redis-py connection where URL contains auth:
  try:
      r = redis.from_url(redis_url)
      r.ping() # Test connection
      print("Successfully connected to Redis!")
  except Exception as e:
      print(f"Error connecting to Redis: {e}")
      # Re-raise or handle appropriately

• Upstash Specifics: If coaia is designed to interact with Upstash Redis REST API specifically, the redis-py library might not be the direct client. Instead, it would involve HTTP requests. In that case, ensure the UPSTASH_REDIS_REST_TOKEN is correctly included in the Authorization header or as part of the request body for every API call.

3. Configuration Precedence

Adjustment: Clearly define and implement a configuration loading hierarchy.

Guidance:

1. Environment Variables (.env): Highest precedence. Loaded first using python-dotenv.
2. User-specific Configuration (~/.coaia.json): Fallback if not found in environment variables.
3. Project-specific Configuration (./coaia.json): Fallback if not found in user-specific config.
4. Application Defaults: Lowest precedence.

This hierarchy ensures that local .env settings override global or default configurations, providing flexibility for development and deployment.

4. Enhanced Error Handling and Logging

Adjustment: Provide more informative error messages to aid debugging.

Guidance:

• When a connection fails, log the specific error from the Redis client library.
• Indicate which configuration source was attempted (e.g., "Attempted connection using credentials from .env file...").
• Suggest common troubleshooting steps (e.g., "Verify UPSTASH_REDIS_REST_URL and UPSTASH_REDIS_REST_TOKEN are correctly set.").

5. Code Location for Changes

Based on the file structure, likely candidates for these adjustments are:

• coaiapy/coaiacli.py: For the main CLI entry point and initial .env loading.
• coaiapy/cofuse.py: If this module handles the core Redis interactions for coaia fuse commands.
• coaiapy/environment.py: A potential dedicated module for environment and configuration management, if one exists or is to be created.

By implementing these adjustments, the coaia tash and coaia fetch commands should reliably connect to Redis using the specified credentials, resolving the current authentication errors.

Appendix: GitHub Environment Variables

For deployment and continuous integration environments, it is expected that the UPSTASH_REDIS_REST_URL and UPSTASH_REDIS_REST_TOKEN variables will be securely configured within the "copilot" GitHub environment. Copilot agents should be aware that these variables will be available in that context and should be utilized for Redis connections in such environments.

[jgwill]

Not fixed at all