replicas-engine 0.1.335 → 0.1.336

package/dist/src/index.js

@@ -291,7 +291,7 @@ var WORKSPACE_SIZES = ["small", "large"];
 var INVALID_WORKSPACE_SIZE_ERROR = `Invalid size: must be one of ${WORKSPACE_SIZES.join(", ")}`;
 
 // ../shared/src/e2b.ts
-var E2B_TEMPLATE_NAME = "replicas-sandbox-2026-06-22-v1";
+var E2B_TEMPLATE_NAME = "replicas-sandbox-2026-06-22-v2";
 
 // ../shared/src/runtime-env.ts
 function parsePosixEnvFile(content) {
@@ -377,6 +377,51 @@ var InFlightMap = class {
   }
 };
 
+// ../shared/src/github/url.ts
+var GITHUB_HOST_RE = /(^|@|\/\/)github\.com[:/]/;
+function isGitHubUrl(url) {
+  if (!url) return false;
+  return GITHUB_HOST_RE.test(url);
+}
+function stripCredentialsFromUrl(url) {
+  try {
+    const parsed = new URL(url);
+    if (parsed.username || parsed.password) {
+      parsed.username = "";
+      parsed.password = "";
+      return parsed.toString();
+    }
+  } catch {
+  }
+  return url;
+}
+
+// ../shared/src/urls.ts
+function decodePathSegments(segments) {
+  return segments.map((segment) => {
+    try {
+      return decodeURIComponent(segment);
+    } catch {
+      return segment;
+    }
+  });
+}
+function normalizeRepositoryUrl(url, options = {}) {
+  if (!url) return null;
+  const stripped = stripCredentialsFromUrl(url).trim().replace(/\/+$/, "").replace(/\.git$/, "");
+  if (!stripped) return null;
+  try {
+    const parsed = new URL(stripped);
+    parsed.hash = "";
+    parsed.search = "";
+    parsed.pathname = parsed.pathname.replace(/\/+$/, "").replace(/\.git$/, "");
+    const normalized = `${parsed.origin}${parsed.pathname}`;
+    return options.lowercase ? normalized.toLowerCase() : normalized;
+  } catch {
+    return options.lowercase ? stripped.toLowerCase() : stripped;
+  }
+}
+
 // ../shared/src/slash-commands.ts
 var MAX_CODEX_GOAL_OBJECTIVE_CHARS = 4e3;
 function parseGoalCommand(message) {
@@ -2734,13 +2779,6 @@ var MEDIA_KIND = {
 };
 var MEDIA_KINDS = [MEDIA_KIND.IMAGE, MEDIA_KIND.VIDEO, MEDIA_KIND.AUDIO];
 
-// ../shared/src/github/url.ts
-var GITHUB_HOST_RE = /(^|@|\/\/)github\.com[:/]/;
-function isGitHubUrl(url) {
-  if (!url) return false;
-  return GITHUB_HOST_RE.test(url);
-}
-
 // ../shared/src/skill-registry.ts
 var SKILL_REGISTRY_MANIFEST_VERSION = 1;
 
@@ -3562,8 +3600,8 @@ var GitService = class {
   defaultBranchCache = /* @__PURE__ */ new Map();
   cachedPrByRepo = /* @__PURE__ */ new Map();
   // No invalidation on purpose — `git remote set-url` mid-session is rare and
-  // the worst case is `gh pr view` stays skipped until the next engine restart.
-  originIsGitHubCache = /* @__PURE__ */ new Map();
+  // the worst case is PR/MR lookup stays skipped until the next engine restart.
+  originInfoCache = /* @__PURE__ */ new Map();
   // Broadcaster + UI /repos requests fan in here every ~2s; one shared run.
   listReposInFlight = new InFlightMap();
   diffStatsInFlight = new InFlightMap();
@@ -3926,7 +3964,8 @@ var GitService = class {
     }
   }
   async lookupPrOnRemote(repoName, repoPath, branch) {
-    if (!await this.originIsGitHub(repoPath)) {
+    const origin = await this.getOriginInfo(repoPath);
+    if (origin.provider === "unknown") {
       return { status: "not_found" };
     }
     try {
@@ -3941,6 +3980,9 @@ var GitService = class {
     } catch {
       return { status: "error" };
     }
+    if (origin.provider === "gitlab") {
+      return this.lookupGitLabMrOnRemote(repoName, origin.gitLab, branch);
+    }
     try {
       const { stdout } = await execFileAsync("gh", ["pr", "view", branch, "--json", "url", "--jq", ".url"], {
         cwd: repoPath,
@@ -3955,24 +3997,120 @@ var GitService = class {
       return { status: "error" };
     }
   }
-  async originIsGitHub(repoPath) {
-    const cached = this.originIsGitHubCache.get(repoPath);
+  async lookupGitLabMrOnRemote(repoName, remote, branch) {
+    const token = await this.getGitLabAccessToken(remote.host);
+    if (!token) {
+      return { status: "not_found" };
+    }
+    const url = `${remote.instanceUrl}/api/v4/projects/${encodeURIComponent(remote.projectPath)}/merge_requests?state=opened&source_branch=${encodeURIComponent(branch)}`;
+    try {
+      const response = await fetch(url, {
+        headers: { Authorization: `Bearer ${token}` },
+        signal: AbortSignal.timeout(1e4)
+      });
+      if (!response.ok) {
+        console.warn(`[GitService] GitLab MR lookup failed for ${repoName}: ${response.status}`);
+        return response.status === 404 ? { status: "not_found" } : { status: "error" };
+      }
+      const data = await response.json();
+      if (!Array.isArray(data)) return { status: "not_found" };
+      const mergeRequest = data.find((item) => isRecord4(item) && item.source_branch === branch) ?? data[0];
+      if (!isRecord4(mergeRequest)) return { status: "not_found" };
+      const webUrl = mergeRequest.web_url;
+      if (typeof webUrl === "string" && webUrl.length > 0) return { status: "found", url: webUrl };
+      const iid = mergeRequest.iid;
+      return typeof iid === "number" ? { status: "found", url: `${remote.instanceUrl}/${remote.projectPath}/-/merge_requests/${iid}` } : { status: "not_found" };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.warn(`[GitService] GitLab MR lookup failed for ${repoName}: ${message}`);
+      return { status: "error" };
+    }
+  }
+  async getOriginInfo(repoPath) {
+    const cached = this.originInfoCache.get(repoPath);
     if (cached !== void 0) {
       return cached;
     }
-    let isGitHub = false;
+    let info = { provider: "unknown" };
     try {
       const { stdout } = await execFileAsync("git", ["remote", "get-url", "origin"], {
         cwd: repoPath,
         encoding: "utf-8",
         maxBuffer: SUBPROCESS_MAX_BUFFER
       });
-      isGitHub = isGitHubUrl(stdout.trim());
+      const originUrl = stdout.trim();
+      if (isGitHubUrl(originUrl)) {
+        info = { provider: "github" };
+      } else {
+        const gitLabRemote = this.parseGitLabRemote(originUrl);
+        if (gitLabRemote) info = { provider: "gitlab", gitLab: gitLabRemote };
+      }
     } catch {
-      isGitHub = false;
+      info = { provider: "unknown" };
     }
-    this.originIsGitHubCache.set(repoPath, isGitHub);
-    return isGitHub;
+    this.originInfoCache.set(repoPath, info);
+    return info;
+  }
+  parseGitLabRemote(remoteUrl) {
+    const sshUrl = remoteUrl.trim().replace(/\/+$/, "").replace(/\.git$/, "");
+    try {
+      const parsed = new URL(sshUrl);
+      if (parsed.protocol === "ssh:") {
+        const projectPath = decodePathSegments(parsed.pathname.split("/").filter(Boolean)).join("/");
+        if (!parsed.hostname || !projectPath) return null;
+        const host = parsed.hostname.toLowerCase();
+        return {
+          host,
+          instanceUrl: `https://${host}`,
+          projectPath
+        };
+      }
+    } catch {
+    }
+    const scpLike = sshUrl.match(/^git@([^:/]+):(?:(?:\d+)\/)?(.+)$/);
+    if (scpLike) {
+      const [, host, projectPath] = scpLike;
+      if (!host || !projectPath) return null;
+      const decodedProjectPath = decodePathSegments(projectPath.split("/").filter(Boolean)).join("/");
+      return {
+        host: host.toLowerCase(),
+        instanceUrl: `https://${host}`,
+        projectPath: decodedProjectPath
+      };
+    }
+    const normalized = normalizeRepositoryUrl(remoteUrl);
+    if (!normalized) return null;
+    try {
+      const parsed = new URL(normalized);
+      if (parsed.protocol !== "https:" && parsed.protocol !== "http:") return null;
+      const projectPath = decodePathSegments(parsed.pathname.split("/").filter(Boolean)).join("/");
+      if (!projectPath) return null;
+      return {
+        host: parsed.host.toLowerCase(),
+        instanceUrl: parsed.origin,
+        projectPath
+      };
+    } catch {
+    }
+    return null;
+  }
+  async getGitLabAccessToken(host) {
+    try {
+      const credentials = await readFile3(join5(ENGINE_ENV.HOME_DIR, ".git-credentials"), "utf-8");
+      for (const line of credentials.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+        try {
+          const parsed = new URL(trimmed);
+          if (parsed.protocol === "https:" && parsed.host.toLowerCase() === host && parsed.password) {
+            return decodeURIComponent(parsed.password);
+          }
+        } catch {
+        }
+      }
+    } catch {
+    }
+    return null;
   }
   async resolveDefaultBranch(repoPath) {
     const cached = this.defaultBranchCache.get(repoPath);
@@ -7359,7 +7497,7 @@ var AspClient = class {
 // src/managers/codex-asp/app-server-process.ts
 var DEFAULT_CODEX_BINARY = "codex";
 var DEFAULT_CODEX_ARGS = ["app-server", "--listen", "stdio://"];
-var ENGINE_PACKAGE_VERSION = "0.1.335";
+var ENGINE_PACKAGE_VERSION = "0.1.336";
 var INITIALIZE_METHOD = "initialize";
 var INITIALIZED_NOTIFICATION = "initialized";
 var ACCOUNT_LOGIN_START_METHOD = "account/login/start";
@@ -10798,10 +10936,12 @@ var ChatService = class {
     }
   }
   async publishAgentTurnCompleteWebhook(chat) {
-    try {
-      await githubTokenManager.refreshOnce();
-    } catch {
-    }
+    await Promise.all([
+      githubTokenManager.refreshOnce().catch(() => {
+      }),
+      gitlabTokenManager.refreshOnce().catch(() => {
+      })
+    ]);
     const linearSessionId = ENGINE_ENV.LINEAR_SESSION_ID;
     const observedBranches = chat.observedBranchesByRepo;
     chat.observedBranchesByRepo = /* @__PURE__ */ new Map();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "replicas-engine",
-  "version": "0.1.335",
+  "version": "0.1.336",
   "description": "Lightweight API server for Replicas workspaces",
   "type": "module",
   "main": "dist/src/index.js",