fix(cli): resolve relative paths and tilde for local config switching

extensions/cli/src/auth/uriUtils.test.ts

@@ -0,0 +1,136 @@
+import * as os from "os";
+import * as path from "path";
+import { describe, expect, it } from "vitest";
+import { pathToUri, slugToUri, uriToPath, uriToSlug } from "./uriUtils.js";
+
+describe("uriUtils", () => {
+    describe("pathToUri", () => {
+        it("should convert absolute paths to file:// URIs", () => {
+            const absolutePath = "/home/user/.continue/config.yaml";
+            const uri = pathToUri(absolutePath);
+            expect(uri).toBe(`file://${absolutePath}`);
+        });
+
+        it("should resolve relative paths to absolute paths", () => {
+            const relativePath = "./config.yaml";
+            const uri = pathToUri(relativePath);
+
+            // Should be absolute, not relative
+            expect(uri).toMatch(/^file:\/\//);
+            expect(uri).not.toContain("./");
+
+            // Should contain the current working directory
+            const expectedPath = path.resolve(relativePath);
+            expect(uri).toBe(`file://${expectedPath}`);
+        });
+
+        it("should expand tilde (~) to home directory", () => {
+            const tildePath = "~/.continue/config.yaml";
+            const uri = pathToUri(tildePath);
+
+            const expectedPath = path.join(os.homedir(), ".continue/config.yaml");
+            expect(uri).toBe(`file://${expectedPath}`);
+        }); it("should handle paths starting with ../", () => {
+            const parentPath = "../config.yaml";
+            const uri = pathToUri(parentPath);
+
+            // Should be absolute
+            expect(uri).toMatch(/^file:\/\//);
+            expect(uri).not.toContain("../");
+
+            const expectedPath = path.resolve(parentPath);
+            expect(uri).toBe(`file://${expectedPath}`);
+        });
+
+        it("should handle Windows absolute paths", () => {
+            // This test will pass on any OS since we're just checking the logic
+            const windowsPath = "C:\\Users\\user\\.continue\\config.yaml";
+            const uri = pathToUri(windowsPath);
+
+            expect(uri).toMatch(/^file:\/\//);
+        });
+    });
+
+    describe("slugToUri", () => {
+        it("should convert assistant slug to slug:// URI", () => {
+            const slug = "continuedev/default-agent";
+            const uri = slugToUri(slug);
+            expect(uri).toBe("slug://continuedev/default-agent");
+        });
+    });
+
+    describe("uriToPath", () => {
+        it("should extract path from file:// URI", () => {
+            const uri = "file:///home/user/.continue/config.yaml";
+            const extractedPath = uriToPath(uri);
+            expect(extractedPath).toBe("/home/user/.continue/config.yaml");
+        });
+
+        it("should return null for non-file:// URIs", () => {
+            const uri = "slug://continuedev/default-agent";
+            const extractedPath = uriToPath(uri);
+            expect(extractedPath).toBeNull();
+        });
+
+        it("should return null for invalid URIs", () => {
+            const uri = "not-a-uri";
+            const extractedPath = uriToPath(uri);
+            expect(extractedPath).toBeNull();
+        });
+    });
+
+    describe("uriToSlug", () => {
+        it("should extract slug from slug:// URI", () => {
+            const uri = "slug://continuedev/default-agent";
+            const extractedSlug = uriToSlug(uri);
+            expect(extractedSlug).toBe("continuedev/default-agent");
+        });
+
+        it("should return null for non-slug:// URIs", () => {
+            const uri = "file:///home/user/.continue/config.yaml";
+            const extractedSlug = uriToSlug(uri);
+            expect(extractedSlug).toBeNull();
+        });
+
+        it("should return null for invalid URIs", () => {
+            const uri = "not-a-uri";
+            const extractedSlug = uriToSlug(uri);
+            expect(extractedSlug).toBeNull();
+        });
+    });
+
+    describe("round-trip conversions", () => {
+        it("should correctly round-trip absolute file paths", () => {
+            const originalPath = "/home/user/.continue/config.yaml";
+            const uri = pathToUri(originalPath);
+            const extractedPath = uriToPath(uri);
+            expect(extractedPath).toBe(originalPath);
+        });
+
+        it("should correctly round-trip relative file paths (after resolution)", () => {
+            const relativePath = "./config.yaml";
+            const uri = pathToUri(relativePath);
+            const extractedPath = uriToPath(uri);
+
+            // The extracted path should be absolute, not the original relative path
+            expect(extractedPath).toBe(path.resolve(relativePath));
+        });
+
+        it("should correctly round-trip tilde paths (after expansion)", () => {
+            const tildePath = "~/.continue/config.yaml";
+            const uri = pathToUri(tildePath);
+            const extractedPath = uriToPath(uri);
+
+            // The extracted path should be the expanded home directory path
+            const expectedPath = path.join(os.homedir(), ".continue/config.yaml");
+            expect(extractedPath).toBe(expectedPath);
+        });
+
+        it("should correctly round-trip assistant slugs", () => {
+            const originalSlug = "continuedev/default-agent";
+            const uri = slugToUri(originalSlug);
+            const extractedSlug = uriToSlug(uri);
+            expect(extractedSlug).toBe(originalSlug);
+        });
+    });
+});

extensions/cli/src/auth/uriUtils.ts

@@ -2,8 +2,26 @@
  * URI utility functions for auth config
  */
 
-export function pathToUri(path: string): string {
-  return `file://${path}`;
+import * as os from "os";
+import * as path from "path";
+
+/**
+ * Resolves a file path to an absolute path, handling tilde expansion
+ */
+function resolveFilePath(filePath: string): string {
+  // Handle tilde (~) expansion for home directory
+  if (filePath.startsWith("~/")) {
+    return path.join(os.homedir(), filePath.slice(2));
+  }
+
+  // Resolve relative paths to absolute paths
+  return path.resolve(filePath);
+}
+
+export function pathToUri(filePath: string): string {
+  // Ensure we always create valid file:// URIs with absolute paths
+  const absolutePath = resolveFilePath(filePath);
+  return `file://${absolutePath}`;
 }
 
 export function slugToUri(slug: string): string {

extensions/cli/src/configLoader.ts

@@ -1,6 +1,7 @@
 import * as fs from "fs";
 import { dirname } from "node:path";
 import { fileURLToPath } from "node:url";
+import * as os from "os";
 import * as path from "path";
 
 import {
@@ -314,7 +315,7 @@ async function loadUserAssistantWithFallback(
     if (errors?.some((e: any) => e.fatal)) {
       throw new Error(
         errors.map((e: any) => e.message).join("\n") ??
-          "Failed to load assistant.",
+        "Failed to load assistant.",
       );
     }
     let apiConfig = result.config as AssistantUnrolled;
@@ -533,7 +534,7 @@ async function loadAssistantSlug(
   if (errors?.some((e: any) => e.fatal)) {
     throw new Error(
       errors.map((e: any) => e.message).join("\n") ??
-        "Failed to load assistant.",
+      "Failed to load assistant.",
     );
   }
   let apiConfig = result.config as AssistantUnrolled;
@@ -569,15 +570,32 @@ function isFilePath(configPath: string): boolean {
   );
 }
 
+/**
+ * Resolves a file path to an absolute path, handling tilde expansion
+ */
+function resolveFilePath(filePath: string): string {
+  // Handle tilde (~) expansion for home directory
+  if (filePath.startsWith("~/")) {
+    return path.join(os.homedir(), filePath.slice(2));
+  }
+
+  // Resolve relative paths to absolute paths
+  return path.resolve(filePath);
+}
+
 /**
  * Converts a config source back to a URI for persistence
+ * Ensures file paths are converted to absolute paths before creating URIs
  */
 function getUriFromSource(source: ConfigSource): string | null {
   switch (source.type) {
     case "cli-flag":
-      return isFilePath(source.path)
-        ? `file://${source.path}`
-        : `slug://${source.path}`;
+      if (isFilePath(source.path)) {
+        // Resolve relative paths and tilde to absolute paths before creating file:// URI
+        const absolutePath = resolveFilePath(source.path);
+        return `file://${absolutePath}`;
+      }
+      return `slug://${source.path}`;
     case "saved-uri":
       return source.uri;
     case "default-config-yaml":

extensions/cli/src/e2e/local-config-switching.test.tsx

@@ -39,6 +39,8 @@ describe("Local Config Switching Investigation", () => {
 
   test("documents the local config switching problem", () => {
     // User reported issue: "Switching configs always works except when I'm using a local config"
+    // FIXED: The issue was in getUriFromSource() and pathToUri() functions not resolving
+    // relative paths and tilde expansion before creating file:// URIs
 
     const problemScenarios = [
       {
@@ -52,40 +54,28 @@ describe("Local Config Switching Investigation", () => {
         name: "Remote to Local switching",
         from: "continuedev/default-agent",
         to: "~/.continue/config.yaml",
-        works: false, // This is the reported issue
-        reason: "UNKNOWN - this is what we need to debug",
+        works: true, // FIXED!
+        reason: "Now properly resolves tilde and creates valid file:// URI",
       },
       {
         name: "Local to Remote switching",
         from: "~/.continue/config.yaml",
         to: "continuedev/default-agent",
-        works: false, // Likely also broken
-        reason: "UNKNOWN - probably same root cause",
+        works: true, // FIXED!
+        reason: "File path is properly resolved before creating URI",
       },
       {
         name: "Local to Local switching",
         from: "~/.continue/config.yaml",
         to: "./other-config.yaml",
-        works: false, // Likely also broken
-        reason: "UNKNOWN - probably same root cause",
+        works: true, // FIXED!
+        reason: "Relative paths are now resolved to absolute paths",
       },
     ];
 
-    // The problem is specifically with local configs
+    // All scenarios should now work
     const brokenScenarios = problemScenarios.filter((s) => !s.works);
-    expect(brokenScenarios.length).toBeGreaterThan(0);
-
-    // All broken scenarios involve local configs
-    const allInvolveLocalConfigs = brokenScenarios.every(
-      (scenario) =>
-        scenario.from.includes("/") ||
-        scenario.from.includes("~") ||
-        scenario.from.includes(".") ||
-        scenario.to.includes("/") ||
-        scenario.to.includes("~") ||
-        scenario.to.includes("."),
-    );
-    expect(allInvolveLocalConfigs).toBe(true);
+    expect(brokenScenarios.length).toBe(0);
   });
 
   test("hypothesis: local config loading has different behavior", async () => {