@malloy-publisher/server 0.0.227 → 0.0.229

package/src/service/environment_store.spec.ts

@@ -7,10 +7,17 @@ import { isPublisherConfigFrozen } from "../config";
 import { TEMP_DIR_PATH } from "../constants";
 import { BadRequestError } from "../errors";
 import { Environment } from "./environment";
-import { EnvironmentStore } from "./environment_store";
+import { EnvironmentStore, resolvePackageLocation } from "./environment_store";
 
 type MockData = Record<string, unknown>;
 
+// Environments the mock database reports at boot. Empty by default, which makes
+// initialize() fall back to the config file — the path every other test here
+// exercises. Set it to reach the database-restore branch instead, which is the
+// one a real restart against an existing publisher.db takes. Read at call time,
+// so a test can assign it before constructing the store.
+let mockDbEnvironments: unknown[] = [];
+
 mock.module("../storage/StorageManager", () => {
    return {
       StorageManager: class MockStorageManager {
@@ -21,7 +28,8 @@ mock.module("../storage/StorageManager", () => {
          getRepository() {
             return {
                // ===== PROJECT METHODS =====
-               listEnvironments: async (): Promise<unknown[]> => [],
+               listEnvironments: async (): Promise<unknown[]> =>
+                  mockDbEnvironments,
 
                getEnvironmentById: async (
                   id: string,
@@ -194,6 +202,10 @@ describe("EnvironmentStore Service", () => {
          rmSync(serverRootPath, { recursive: true, force: true });
       }
       mkdirSync(serverRootPath);
+      // Default every test back to the config-file boot path. bun runs all specs
+      // in one process, so a leaked value would silently switch later tests onto
+      // the database-restore branch.
+      mockDbEnvironments = [];
       sandbox = sinon.createSandbox();
 
       // Mock the configuration to prevent initialization errors
@@ -212,6 +224,7 @@ describe("EnvironmentStore Service", () => {
          rmSync(serverRootPath, { recursive: true, force: true });
       }
       mkdirSync(serverRootPath);
+      mockDbEnvironments = [];
       sandbox.restore();
    });
 
@@ -410,6 +423,294 @@ describe("EnvironmentStore Service", () => {
       await expect(
          newEnvironmentStore.getEnvironment(invalidProjectName),
       ).rejects.toThrow();
+
+      // The skip is not fatal, so the server still serves. getStatus is the
+      // only place that says the environment is missing rather than never
+      // configured: without loadErrors the two are indistinguishable.
+      const status = await newEnvironmentStore.getStatus();
+      expect(status.operationalState).toBe("serving");
+      expect(status.environments.map((e) => e.name)).toEqual([
+         validProjectName,
+      ]);
+      expect(status.loadErrors).toHaveLength(1);
+      expect(status.loadErrors?.[0]?.environment).toBe(invalidProjectName);
+      expect(status.loadErrors?.[0]?.package).toBeUndefined();
+      expect(status.loadErrors?.[0]?.message).toBeTruthy();
+   });
+
+   it("should omit loadErrors when every environment loads", async () => {
+      const projectPath = path.join(serverRootPath, projectName);
+      mkdirSync(projectPath, { recursive: true });
+      writeFileSync(
+         path.join(projectPath, "publisher.json"),
+         JSON.stringify({ name: projectName, description: "Test package" }),
+      );
+      writeFileSync(
+         path.join(serverRootPath, "publisher.config.json"),
+         JSON.stringify({
+            frozenConfig: false,
+            environments: [
+               {
+                  name: projectName,
+                  packages: [{ name: projectName, location: projectPath }],
+                  connections: [],
+               },
+            ],
+         }),
+      );
+
+      const newEnvironmentStore = new EnvironmentStore(serverRootPath);
+      await newEnvironmentStore.finishedInitialization;
+
+      // Absent, not an empty array: a healthy status is unchanged by this
+      // field's existence.
+      const status = await newEnvironmentStore.getStatus();
+      expect(status.operationalState).toBe("serving");
+      expect(status.loadErrors).toBeUndefined();
+      expect("loadErrors" in status).toBe(false);
+   });
+
+   it("should not report an environment that is serving even if its database sync fails", async () => {
+      // An environment reaches this.environments before addEnvironmentToDatabase
+      // runs, so a throw from that tail is caught by the same handler that
+      // records load failures. The environment is live and listed, so reporting
+      // it as a load failure would make the status contradict itself.
+      const projectPath = path.join(serverRootPath, projectName);
+      mkdirSync(projectPath, { recursive: true });
+      writeFileSync(
+         path.join(projectPath, "publisher.json"),
+         JSON.stringify({ name: projectName }),
+      );
+      writeFileSync(
+         path.join(serverRootPath, "publisher.config.json"),
+         JSON.stringify({
+            frozenConfig: false,
+            environments: [
+               {
+                  name: projectName,
+                  packages: [{ name: projectName, location: projectPath }],
+                  connections: [],
+               },
+            ],
+         }),
+      );
+
+      // Stub the prototype before constructing: the constructor starts
+      // initialize() immediately, so stubbing the instance would race it.
+      sandbox
+         .stub(EnvironmentStore.prototype, "addEnvironmentToDatabase")
+         .rejects(new Error("database write failed"));
+
+      const newEnvironmentStore = new EnvironmentStore(serverRootPath);
+      await newEnvironmentStore.finishedInitialization;
+
+      const status = await newEnvironmentStore.getStatus();
+      expect(status.operationalState).toBe("serving");
+      // Still serving it, so it must not also be reported as not loaded.
+      expect(status.environments.map((e) => e.name)).toEqual([projectName]);
+      expect(status.loadErrors).toBeUndefined();
+   });
+
+   it("should report an environment that failed to restore from the database", async () => {
+      // The database-restore branch, not the config branch: initialize() takes
+      // this one whenever INITIALIZE_STORAGE is not "true" and the database
+      // already holds environments, which is every restart of a server with a
+      // persisted publisher.db. It has its own catch, so a failure recorded only
+      // on the config path would be dropped on the path production actually
+      // takes.
+      const envName = "restored-env";
+      const envPath = path.join(serverRootPath, envName);
+
+      // Exists, so the "files missing" branch is skipped, but is a file rather
+      // than a directory, so Environment.create throws. Stands in for any stored
+      // path that goes bad between restarts.
+      writeFileSync(envPath, "not a directory");
+
+      writeFileSync(
+         path.join(serverRootPath, "publisher.config.json"),
+         JSON.stringify({
+            frozenConfig: false,
+            environments: [
+               {
+                  name: envName,
+                  packages: [{ name: envName, location: envPath }],
+                  connections: [],
+               },
+            ],
+         }),
+      );
+
+      mockDbEnvironments = [
+         {
+            id: "restored-env-id",
+            name: envName,
+            path: envPath,
+            metadata: {},
+         },
+      ];
+
+      const newEnvironmentStore = new EnvironmentStore(serverRootPath);
+      await newEnvironmentStore.finishedInitialization;
+
+      const status = await newEnvironmentStore.getStatus();
+      expect(status.operationalState).toBe("serving");
+      expect(status.environments.map((e) => e.name)).toEqual([]);
+      expect(status.loadErrors).toHaveLength(1);
+      expect(status.loadErrors?.[0]?.environment).toBe(envName);
+      expect(status.loadErrors?.[0]?.message).toBeTruthy();
+   });
+
+   it("should report a package that failed to load while its siblings serve", async () => {
+      const goodPackageName = "good-package";
+      const badPackageName = "bad-package";
+      const goodPackagePath = path.join(serverRootPath, goodPackageName);
+      const badPackagePath = path.join(serverRootPath, badPackageName);
+
+      mkdirSync(goodPackagePath, { recursive: true });
+      writeFileSync(
+         path.join(goodPackagePath, "publisher.json"),
+         JSON.stringify({ name: goodPackageName }),
+      );
+      // The directory exists, so the environment mounts; the package inside it
+      // has no manifest, so only that package fails. This is the second, and
+      // quieter, failure mode: the environment is present and serving, with a
+      // package missing from it.
+      mkdirSync(badPackagePath, { recursive: true });
+
+      writeFileSync(
+         path.join(serverRootPath, "publisher.config.json"),
+         JSON.stringify({
+            frozenConfig: false,
+            environments: [
+               {
+                  name: projectName,
+                  packages: [
+                     { name: goodPackageName, location: goodPackagePath },
+                     { name: badPackageName, location: badPackagePath },
+                  ],
+                  connections: [],
+               },
+            ],
+         }),
+      );
+
+      const newEnvironmentStore = new EnvironmentStore(serverRootPath);
+      await newEnvironmentStore.finishedInitialization;
+
+      const environment = await newEnvironmentStore.getEnvironment(projectName);
+      const packages = await environment.listPackages();
+      expect(packages.map((p) => p.name)).toEqual([goodPackageName]);
+
+      const status = await newEnvironmentStore.getStatus();
+      expect(status.operationalState).toBe("serving");
+      expect(status.loadErrors).toHaveLength(1);
+      expect(status.loadErrors?.[0]?.environment).toBe(projectName);
+      expect(status.loadErrors?.[0]?.package).toBe(badPackageName);
+      expect(status.loadErrors?.[0]?.message).toBeTruthy();
+   });
+
+   it("should stop reporting a failed package once it is deleted", async () => {
+      const goodPackageName = "good-package";
+      const badPackageName = "bad-package";
+      const goodPackagePath = path.join(serverRootPath, goodPackageName);
+      const badPackagePath = path.join(serverRootPath, badPackageName);
+
+      mkdirSync(goodPackagePath, { recursive: true });
+      writeFileSync(
+         path.join(goodPackagePath, "publisher.json"),
+         JSON.stringify({ name: goodPackageName }),
+      );
+      mkdirSync(badPackagePath, { recursive: true });
+
+      writeFileSync(
+         path.join(serverRootPath, "publisher.config.json"),
+         JSON.stringify({
+            frozenConfig: false,
+            environments: [
+               {
+                  name: projectName,
+                  packages: [
+                     { name: goodPackageName, location: goodPackagePath },
+                     { name: badPackageName, location: badPackagePath },
+                  ],
+                  connections: [],
+               },
+            ],
+         }),
+      );
+
+      const newEnvironmentStore = new EnvironmentStore(serverRootPath);
+      await newEnvironmentStore.finishedInitialization;
+
+      const environment = await newEnvironmentStore.getEnvironment(projectName);
+      expect((await newEnvironmentStore.getStatus()).loadErrors).toHaveLength(
+         1,
+      );
+
+      // A package that failed to load was evicted from `packages`, so the
+      // delete takes deletePackage's early return. The failure entry has to be
+      // cleared anyway: the caller goes on to drop the package's config row,
+      // and a loadError naming a package that is no longer configured sends
+      // whoever reads /status hunting for something that isn't there.
+      await environment.deletePackage(badPackageName);
+
+      const status = await newEnvironmentStore.getStatus();
+      expect(status.operationalState).toBe("serving");
+      expect(status.loadErrors).toBeUndefined();
+      expect((await environment.listPackages()).map((p) => p.name)).toEqual([
+         goodPackageName,
+      ]);
+   });
+
+   it("should stop reporting a failed package once it loads", async () => {
+      const badPackageName = "bad-package";
+      const badPackagePath = path.join(serverRootPath, badPackageName);
+
+      // No manifest, so it fails to load and lands in loadErrors.
+      mkdirSync(badPackagePath, { recursive: true });
+
+      writeFileSync(
+         path.join(serverRootPath, "publisher.config.json"),
+         JSON.stringify({
+            frozenConfig: false,
+            environments: [
+               {
+                  name: projectName,
+                  packages: [
+                     { name: badPackageName, location: badPackagePath },
+                  ],
+                  connections: [],
+               },
+            ],
+         }),
+      );
+
+      const newEnvironmentStore = new EnvironmentStore(serverRootPath);
+      await newEnvironmentStore.finishedInitialization;
+
+      const environment = await newEnvironmentStore.getEnvironment(projectName);
+      expect((await newEnvironmentStore.getStatus()).loadErrors).toHaveLength(
+         1,
+      );
+
+      // Fix the package where the environment actually reads it, then re-add
+      // it. A package that is serving must not still be reported as failed.
+      writeFileSync(
+         path.join(
+            environment.metadata.location as string,
+            badPackageName,
+            "publisher.json",
+         ),
+         JSON.stringify({ name: badPackageName }),
+      );
+      await environment.addPackage(badPackageName);
+
+      const status = await newEnvironmentStore.getStatus();
+      expect(status.operationalState).toBe("serving");
+      expect(status.loadErrors).toBeUndefined();
+      expect((await environment.listPackages()).map((p) => p.name)).toEqual([
+         badPackageName,
+      ]);
    });
 
    it("should handle project updates", async () => {
@@ -1042,3 +1343,72 @@ describe("EnvironmentStore path-injection guards", () => {
       );
    });
 });
+
+describe("resolvePackageLocation", () => {
+   // Built with `path`, not literals: the helper joins with the platform
+   // separator and these specs run on windows-latest too (cross-platform-tests).
+   const HOME = path.join(path.sep, "home", "tester");
+   const CONFIG_DIR = path.join(path.sep, "etc", "publisher");
+
+   it("expands ~/ against the home directory", () => {
+      expect(
+         resolvePackageLocation("~/my-packages/sales", CONFIG_DIR, HOME),
+      ).toBe(path.join(HOME, "my-packages", "sales"));
+   });
+
+   it("does not anchor an expanded ~/ path at the config dir", () => {
+      // Regression: `~/` satisfies isLocalPath but not path.isAbsolute, so an
+      // unexpanded tilde used to be joined onto the anchor, yielding
+      // `<anchor>/~/my-packages/sales`.
+      const resolved = resolvePackageLocation("~/x", CONFIG_DIR, HOME);
+      expect(resolved).not.toContain("~");
+      expect(resolved.startsWith(CONFIG_DIR)).toBe(false);
+   });
+
+   it("returns an absolute location untouched", () => {
+      const absolute = path.join(path.sep, "srv", "packages", "sales");
+      expect(resolvePackageLocation(absolute, CONFIG_DIR, HOME)).toBe(absolute);
+   });
+
+   it("anchors a relative location at the config dir, not the cwd", () => {
+      expect(resolvePackageLocation("./sales", CONFIG_DIR, HOME)).toBe(
+         path.join(CONFIG_DIR, "sales"),
+      );
+   });
+
+   it("anchors a ../ location at the config dir", () => {
+      expect(
+         resolvePackageLocation("../examples/storefront", CONFIG_DIR, HOME),
+      ).toBe(path.join(CONFIG_DIR, "..", "examples", "storefront"));
+   });
+
+   it("throws when ~/ cannot be expanded because no home directory is set", () => {
+      // An empty home must fail loudly: `path.join("", "x")` would otherwise
+      // yield a relative "x" that silently anchors under the config dir.
+      expect(() => resolvePackageLocation("~/x", CONFIG_DIR, "")).toThrow(
+         /home directory is not set/,
+      );
+   });
+
+   it("never consults the home directory for non-tilde locations", () => {
+      // The same empty home that makes a ~/ location throw must be irrelevant
+      // to ./ and absolute locations; home is resolved lazily, tilde-only.
+      expect(resolvePackageLocation("./sales", CONFIG_DIR, "")).toBe(
+         path.join(CONFIG_DIR, "sales"),
+      );
+      const absolute = path.join(path.sep, "srv", "packages", "sales");
+      expect(resolvePackageLocation(absolute, CONFIG_DIR, "")).toBe(absolute);
+   });
+
+   it("expands only the POSIX ~/ prefix; bare ~ and ~user are not home paths", () => {
+      // Neither form satisfies isLocalPath, so in practice they are rejected
+      // upstream as non-local locations; pin here that the resolver itself
+      // never treats them as home-relative either.
+      expect(resolvePackageLocation("~", CONFIG_DIR, HOME)).toBe(
+         path.join(CONFIG_DIR, "~"),
+      );
+      expect(resolvePackageLocation("~user/foo", CONFIG_DIR, HOME)).toBe(
+         path.join(CONFIG_DIR, "~user", "foo"),
+      );
+   });
+});

package/src/service/environment_store.ts

@@ -4,12 +4,14 @@ import { Mutex } from "async-mutex";
 import crypto from "crypto";
 import extract from "extract-zip";
 import * as fs from "fs";
+import * as os from "os";
 import * as path from "path";
 import simpleGit from "simple-git";
 import { Writable } from "stream";
 import { components } from "../api";
 import {
    getProcessedPublisherConfig,
+   getPublisherConfigDir,
    isPublisherConfigFrozen,
    ProcessedEnvironment,
    ProcessedPublisherConfig,
@@ -27,6 +29,7 @@ import {
 } from "../errors";
 import { getOperationalState, markNotReady, markReady } from "../health";
 import { formatDuration, logger } from "../logger";
+import { redactPgSecrets } from "../pg_helpers";
 import {
    assertSafeEnvironmentPath,
    assertSafePackageName,
@@ -37,6 +40,9 @@ import { StorageConfig, StorageManager } from "../storage/StorageManager";
 import { Environment, PackageStatus } from "./environment";
 import type { PackageMemoryGovernor } from "./package_memory_governor";
 type ApiEnvironment = components["schemas"]["Environment"];
+type LoadError = NonNullable<
+   components["schemas"]["ServerStatus"]["loadErrors"]
+>[number];
 
 const AZURE_SUPPORTED_SCHEMES = ["https://", "http://", "abfss://", "az://"];
 const AZURE_DATA_EXTENSIONS = [
@@ -115,9 +121,49 @@ async function clearMountTarget(targetPath: string): Promise<void> {
    }
 }
 
+/**
+ * Absolute on-disk path for a local package `location`.
+ *
+ * `~/` (POSIX form only) expands to the home directory. Anything still
+ * relative resolves against `anchorDir`, the directory holding the active
+ * config, so a config and the packages it points at can be moved or
+ * committed together. Absolute locations are returned untouched.
+ */
+export function resolvePackageLocation(
+   location: string,
+   anchorDir: string,
+   homeDir?: string,
+): string {
+   let expanded = location;
+   if (location.startsWith("~/")) {
+      // Resolved lazily, inside the tilde branch only: os.homedir() can throw
+      // where HOME is unset and there is no passwd entry for the uid (e.g. a
+      // distroless container with runAsUser), and a `./sales` or absolute
+      // location must never fail on that.
+      const home = homeDir ?? os.homedir();
+      if (!home) {
+         throw new Error(
+            `Cannot expand "~" in location "${location}": home directory is not set`,
+         );
+      }
+      expanded = path.join(home, location.slice(2));
+   }
+   return path.isAbsolute(expanded) ? expanded : path.join(anchorDir, expanded);
+}
+
 export class EnvironmentStore {
    public serverRootPath: string;
    private environments: Map<string, Environment> = new Map();
+   /**
+    * Environments that were configured but did not load, keyed by name.
+    *
+    * A load failure is not fatal: the environment is skipped and the server
+    * still reports `serving`. Nothing else remembers it, because the throw
+    * happens before the environment reaches `this.environments` or the
+    * database, so this is the only record that a configured environment is
+    * missing rather than never asked for. Surfaced on `getStatus`.
+    */
+   private failedEnvironments = new Map<string, string>();
    private environmentMutexes = new Map<string, Mutex>();
    public publisherConfigIsFrozen: boolean;
    public finishedInitialization: Promise<void>;
@@ -197,6 +243,15 @@ export class EnvironmentStore {
       }
    }
 
+   /**
+    * Snapshot of the environments currently held in memory. Used by the
+    * standalone materialization scheduler to sweep loaded packages without
+    * touching the database or triggering loads.
+    */
+   public getLoadedEnvironments(): Environment[] {
+      return [...this.environments.values()];
+   }
+
    private async addConfiguredEnvironment(environment: ProcessedEnvironment) {
       try {
          await this.addEnvironment(
@@ -209,11 +264,21 @@ export class EnvironmentStore {
             true,
          );
       } catch (error) {
-         this.logEnvironmentInitializationError(environment.name, error);
+         this.recordEnvironmentInitializationFailure(environment.name, error);
       }
    }
 
-   private logEnvironmentInitializationError(
+   /**
+    * Log a skipped environment AND remember why, for getStatus to report.
+    *
+    * Both boot paths funnel through here: the config path
+    * ({@link addConfiguredEnvironment}) and the database-restore path taken by
+    * every restart against an existing publisher.db. Keeping the record here
+    * rather than in the callers is deliberate: recording it in only one of them
+    * would leave the other silently dropping failures, which is the bug this is
+    * meant to fix.
+    */
+   private recordEnvironmentInitializationFailure(
       environmentName: string | undefined,
       error: unknown,
    ) {
@@ -222,6 +287,24 @@ export class EnvironmentStore {
          `Error initializing environment${label}; skipping environment`,
          this.extractErrorDataFromError(error),
       );
+      // Only record an environment that is genuinely not there. An environment
+      // reaches `this.environments` before the rest of its setup (the database
+      // sync, its package listing) is done, and a throw from that tail lands
+      // here while the environment is live and serving. Reporting it would
+      // contradict `environments`, which still lists it, and a loadErrors entry
+      // with no `package` means the whole environment was skipped. It also could
+      // never be cleared: the clear below only runs when an environment is
+      // created, so a live one would carry the entry until restart.
+      if (environmentName && !this.environments.has(environmentName)) {
+         // Redacted because this is bound for an HTTP response body, not just a
+         // log line; see the same call in environment.ts.
+         this.failedEnvironments.set(
+            environmentName,
+            redactPgSecrets(
+               error instanceof Error ? error.message : String(error),
+            ),
+         );
+      }
    }
 
    private async initialize() {
@@ -340,7 +423,7 @@ export class EnvironmentStore {
 
                         return environmentInstance.listPackages();
                      } catch (error) {
-                        this.logEnvironmentInitializationError(
+                        this.recordEnvironmentInitializationFailure(
                            dbEnvironment.name,
                            error,
                         );
@@ -759,9 +842,16 @@ export class EnvironmentStore {
             : baseState
       ) as components["schemas"]["ServerStatus"]["operationalState"];
 
-      const status = {
+      const status: {
+         timestamp: number;
+         environments: Array<components["schemas"]["Environment"]>;
+         initialized: boolean;
+         frozenConfig: boolean;
+         operationalState: components["schemas"]["ServerStatus"]["operationalState"];
+         loadErrors?: LoadError[];
+      } = {
          timestamp: Date.now(),
-         environments: [] as Array<components["schemas"]["Environment"]>,
+         environments: [],
          initialized: this.isInitialized,
          frozenConfig: isPublisherConfigFrozen(this.serverRootPath),
          operationalState,
@@ -803,6 +893,34 @@ export class EnvironmentStore {
             }
          }),
       );
+
+      // Collected AFTER listEnvironments, not before: serialize() awaits
+      // listPackages(), which is what loads an environment's packages and so
+      // records their failures. Reading the maps at the top of this method risks
+      // reading them before the failures they report have been recorded.
+      //
+      // A read-time overlay over live state, like "throttled" above, so there is
+      // no fourth stored status to keep in sync.
+      const loadErrors: LoadError[] = [];
+      for (const [environmentName, message] of this.failedEnvironments) {
+         loadErrors.push({ environment: environmentName, message });
+      }
+      for (const [environmentName, environment] of this.environments) {
+         for (const [packageName, message] of environment.getFailedPackages()) {
+            loadErrors.push({
+               environment: environmentName,
+               package: packageName,
+               message,
+            });
+         }
+      }
+      // Left unset when nothing failed, so the key is absent from the response
+      // and a healthy server's status body is byte-for-byte what it was before
+      // this field existed.
+      if (loadErrors.length > 0) {
+         status.loadErrors = loadErrors;
+      }
+
       return status;
    }
 
@@ -921,6 +1039,11 @@ export class EnvironmentStore {
       newEnvironment.metadata.location = absoluteEnvironmentPath;
 
       this.environments.set(environmentName, newEnvironment);
+      // It loaded, so any earlier failure for this name is stale. A boot
+      // failure can be followed by a successful POST or lazy load of the same
+      // environment, and a status that keeps reporting the old error would lie
+      // in the other direction.
+      this.failedEnvironments.delete(environmentName);
 
       environment?.packages?.forEach((_package) => {
          if (_package.name) {
@@ -1110,6 +1233,21 @@ export class EnvironmentStore {
       );
    }
 
+   /**
+    * Absolute on-disk path for a local package `location`, anchored at the
+    * directory holding the active config. That covers locations POSTed at
+    * runtime too, which no config declares. When there is no config worth
+    * anchoring to, `getPublisherConfigDir` returns null (it owns the cases) and
+    * the server root is the only meaningful base, which is also what this did
+    * before the anchor moved.
+    */
+   private resolveLocalPath(location: string): string {
+      return resolvePackageLocation(
+         location,
+         getPublisherConfigDir(this.serverRootPath) ?? this.serverRootPath,
+      );
+   }
+
    private isGitHubURL(location: string) {
       return (
          location.startsWith("https://github.com/") ||
@@ -1236,15 +1374,11 @@ export class EnvironmentStore {
                } else {
                   // For non-GitHub locations, use package name
                   if (this.isLocalPath(_package.location)) {
-                     // Match the resolution rule used by
-                     // `downloadOrMountLocation` (line ~1352): relative
-                     // paths are anchored at `serverRootPath`. Without this
-                     // step the existing-source check below falls through
-                     // for any relative location, and the in-place mount
-                     // branch is unreachable.
-                     sourcePath = path.isAbsolute(_package.location)
-                        ? _package.location
-                        : path.join(this.serverRootPath, _package.location);
+                     // Same resolution rule as `downloadOrMountLocation`.
+                     // Without this step the existing-source check below
+                     // falls through for any relative location, and the
+                     // in-place mount branch is unreachable.
+                     sourcePath = this.resolveLocalPath(_package.location);
                   } else {
                      sourcePath = safeJoinUnderRoot(
                         tempDownloadPath,
@@ -1456,9 +1590,7 @@ export class EnvironmentStore {
 
       // Handle absolute and relative paths
       if (this.isLocalPath(location)) {
-         const packagePath: string = path.isAbsolute(location)
-            ? location
-            : path.join(this.serverRootPath, location);
+         const packagePath: string = this.resolveLocalPath(location);
          try {
             logger.info(
                `Mounting local directory at "${packagePath}" to "${targetPath}"`,