opencode-gitlab-duo-agentic 0.1.0 → 0.1.2

package/README.md

@@ -26,13 +26,21 @@ export GITLAB_INSTANCE_URL=https://gitlab.com
 
 ## Optional model configuration
 
-If you generate `models.json` (using `src/scripts/fetch_models.ts`), the plugin resolves it by:
+The plugin discovers models in this order:
 
-1. `options.modelsPath` in provider config
-2. `GITLAB_DUO_MODELS_PATH`
-3. `models.json` found by walking upward from `process.cwd()`
+1. Live GitLab API discovery with cache (TTL default: `86400` seconds)
+2. `models.json` file resolution:
+   - `options.modelsPath` in provider config
+   - `GITLAB_DUO_MODELS_PATH`
+   - `models.json` found by walking upward from `process.cwd()`
+3. Fallback default model `duo-agentic`
 
-If no file is found, it falls back to a default `duo-agentic` model.
+Cache settings:
+
+- Location: `~/.cache/opencode/gitlab-duo-models-*.json`
+- TTL override: `GITLAB_DUO_MODELS_CACHE_TTL` (seconds)
+
+You can still generate a local `models.json` manually using `src/scripts/fetch_models.ts`.
 
 ## Development
 

package/dist/index.d.ts

@@ -18,6 +18,7 @@ type GitLabDuoAgenticProviderOptions = {
     systemRules?: string;
 };
 
-declare function createGitLabDuoAgentic(options: GitLabDuoAgenticProviderOptions): ProviderV2;
+type GitLabDuoAgenticProviderInput = Partial<GitLabDuoAgenticProviderOptions>;
+declare function createGitLabDuoAgentic(options?: GitLabDuoAgenticProviderInput): ProviderV2;
 
 export { GitLabDuoAgenticPlugin, createGitLabDuoAgentic, GitLabDuoAgenticPlugin as default };

package/dist/index.js

@@ -1,10 +1,10 @@
 // src/plugin/config.ts
-import path2 from "path";
-import fs2 from "fs";
+import path4 from "path";
+import fs4 from "fs";
 
 // src/plugin/models.ts
-import path from "path";
-import fs from "fs";
+import path3 from "path";
+import fs3 from "fs";
 
 // src/shared/model_entry.ts
 function buildModelEntry(name) {
@@ -28,12 +28,435 @@ var GITLAB_DUO_DEFAULT_MODEL_NAME = "Duo Agentic";
 var GITLAB_DUO_PLUGIN_PACKAGE_NAME = "opencode-gitlab-duo-agentic";
 var GITLAB_DUO_PROVIDER_NPM_ENTRY = GITLAB_DUO_PLUGIN_PACKAGE_NAME;
 
+// src/plugin/fetch_models.ts
+import crypto from "crypto";
+import os from "os";
+import path2 from "path";
+import fs2 from "fs/promises";
+
+// src/provider/adapters/gitlab_utils.ts
+import fs from "fs/promises";
+import path from "path";
+async function detectProjectPath(cwd, instanceUrl) {
+  let current = cwd;
+  const instance = new URL(instanceUrl);
+  const instanceHost = instance.host;
+  const instanceBasePath = instance.pathname.replace(/\/$/, "");
+  while (true) {
+    try {
+      const config = await readGitConfig(current);
+      const url = extractGitRemoteUrl(config) || "";
+      const remote = parseRemote(url);
+      if (!remote) {
+        return void 0;
+      }
+      if (remote.host !== instanceHost) {
+        throw new Error(
+          `GitLab remote host mismatch. Expected ${instanceHost}, got ${remote.host}.`
+        );
+      }
+      return normalizeProjectPath(remote.path, instanceBasePath);
+    } catch {
+      const parent = path.dirname(current);
+      if (parent === current) return void 0;
+      current = parent;
+    }
+  }
+}
+function extractGitRemoteUrl(config) {
+  const lines = config.split("\n");
+  let inOrigin = false;
+  let originUrl;
+  let firstUrl;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    const sectionMatch = /^\[remote\s+"([^"]+)"\]$/.exec(trimmed);
+    if (sectionMatch) {
+      inOrigin = sectionMatch[1] === "origin";
+      continue;
+    }
+    const urlMatch = /^url\s*=\s*(.+)$/.exec(trimmed);
+    if (urlMatch) {
+      const value = urlMatch[1].trim();
+      if (!firstUrl) firstUrl = value;
+      if (inOrigin) originUrl = value;
+    }
+  }
+  return originUrl ?? firstUrl;
+}
+function parseRemote(remoteUrl) {
+  if (!remoteUrl) return void 0;
+  if (remoteUrl.startsWith("http")) {
+    try {
+      const url = new URL(remoteUrl);
+      return { host: url.host, path: url.pathname.replace(/^\//, "") };
+    } catch {
+      return void 0;
+    }
+  }
+  if (remoteUrl.startsWith("git@")) {
+    const match = /^git@([^:]+):(.+)$/.exec(remoteUrl);
+    if (!match) return void 0;
+    return { host: match[1], path: match[2] };
+  }
+  if (remoteUrl.startsWith("ssh://")) {
+    try {
+      const url = new URL(remoteUrl);
+      return { host: url.host, path: url.pathname.replace(/^\//, "") };
+    } catch {
+      return void 0;
+    }
+  }
+  return void 0;
+}
+function normalizeProjectPath(remotePath, instanceBasePath) {
+  let pathValue = remotePath;
+  if (instanceBasePath && instanceBasePath !== "/") {
+    const base = instanceBasePath.replace(/^\//, "") + "/";
+    if (pathValue.startsWith(base)) {
+      pathValue = pathValue.slice(base.length);
+    }
+  }
+  const cleaned = stripGitSuffix(pathValue);
+  return cleaned.length > 0 ? cleaned : void 0;
+}
+function stripGitSuffix(pathname) {
+  return pathname.endsWith(".git") ? pathname.slice(0, -4) : pathname;
+}
+function buildApiUrl(instanceUrl, apiPath) {
+  const base = instanceUrl.endsWith("/") ? instanceUrl : `${instanceUrl}/`;
+  return new URL(apiPath.replace(/^\//, ""), base).toString();
+}
+function buildAuthHeaders(apiKey) {
+  return { authorization: `Bearer ${apiKey}` };
+}
+async function fetchProjectDetails(instanceUrl, apiKey, projectPath) {
+  const url = buildApiUrl(instanceUrl, `api/v4/projects/${encodeURIComponent(projectPath)}`);
+  const response = await fetch(url, {
+    headers: buildAuthHeaders(apiKey)
+  });
+  if (!response.ok) {
+    throw new Error(`Failed to fetch project details: ${response.status}`);
+  }
+  const data = await response.json();
+  return {
+    projectId: data.id ? String(data.id) : void 0,
+    namespaceId: data.namespace?.id ? String(data.namespace.id) : void 0
+  };
+}
+async function fetchProjectDetailsWithFallback(instanceUrl, apiKey, projectPath) {
+  const candidates = getProjectPathCandidates(projectPath);
+  for (const candidate of candidates) {
+    try {
+      return await fetchProjectDetails(instanceUrl, apiKey, candidate);
+    } catch {
+      continue;
+    }
+  }
+  try {
+    const name = projectPath.split("/").pop() || projectPath;
+    const searchUrl = new URL(buildApiUrl(instanceUrl, "api/v4/projects"));
+    searchUrl.searchParams.set("search", name);
+    searchUrl.searchParams.set("simple", "true");
+    searchUrl.searchParams.set("per_page", "100");
+    searchUrl.searchParams.set("membership", "true");
+    const response = await fetch(searchUrl.toString(), {
+      headers: buildAuthHeaders(apiKey)
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to search projects: ${response.status}`);
+    }
+    const data = await response.json();
+    const match = data.find((project) => project.path_with_namespace === projectPath);
+    if (!match) {
+      throw new Error("Project not found via search");
+    }
+    return {
+      projectId: match.id ? String(match.id) : void 0,
+      namespaceId: match.namespace?.id ? String(match.namespace.id) : void 0
+    };
+  } catch {
+    throw new Error("Project not found via API");
+  }
+}
+function getProjectPathCandidates(projectPath) {
+  const candidates = /* @__PURE__ */ new Set();
+  candidates.add(projectPath);
+  const parts = projectPath.split("/");
+  if (parts.length > 2) {
+    const withoutFirst = parts.slice(1).join("/");
+    candidates.add(withoutFirst);
+  }
+  return Array.from(candidates);
+}
+async function readGitConfig(cwd) {
+  const gitPath = path.join(cwd, ".git");
+  const stat = await fs.stat(gitPath);
+  if (stat.isDirectory()) {
+    return fs.readFile(path.join(gitPath, "config"), "utf8");
+  }
+  const file = await fs.readFile(gitPath, "utf8");
+  const match = /^gitdir:\s*(.+)$/m.exec(file);
+  if (!match) throw new Error("Invalid .git file");
+  const gitdir = match[1].trim();
+  const resolved = path.isAbsolute(gitdir) ? gitdir : path.join(cwd, gitdir);
+  return fs.readFile(path.join(resolved, "config"), "utf8");
+}
+async function resolveRootNamespaceId(instanceUrl, apiKey, namespaceId) {
+  let currentId = namespaceId;
+  for (let depth = 0; depth < 20; depth++) {
+    const url = buildApiUrl(instanceUrl, `api/v4/namespaces/${currentId}`);
+    const response = await fetch(url, {
+      headers: buildAuthHeaders(apiKey)
+    });
+    if (!response.ok) {
+      break;
+    }
+    const data = await response.json();
+    if (!data.parent_id) {
+      currentId = String(data.id ?? currentId);
+      break;
+    }
+    currentId = String(data.parent_id);
+  }
+  return `gid://gitlab/Group/${currentId}`;
+}
+
+// src/plugin/fetch_models.ts
+var DEFAULT_MODELS_CACHE_TTL_SECONDS = 60 * 60 * 24;
+var AVAILABLE_MODELS_QUERY = `query lsp_aiChatAvailableModels($rootNamespaceId: GroupID!) {
+  metadata {
+    featureFlags(names: ["ai_user_model_switching"]) {
+      enabled
+      name
+    }
+    version
+  }
+  aiChatAvailableModels(rootNamespaceId: $rootNamespaceId) {
+    defaultModel { name ref }
+    selectableModels { name ref }
+    pinnedModel { name ref }
+  }
+}`;
+function resolveModelsCacheTtlSeconds() {
+  const raw = process.env.GITLAB_DUO_MODELS_CACHE_TTL;
+  if (!raw) return DEFAULT_MODELS_CACHE_TTL_SECONDS;
+  const parsed = Number.parseInt(raw, 10);
+  if (!Number.isFinite(parsed) || parsed < 0) {
+    return DEFAULT_MODELS_CACHE_TTL_SECONDS;
+  }
+  return parsed;
+}
+async function loadModelsFromCache(options) {
+  const instanceUrl = normalizeInstanceUrl(options.instanceUrl);
+  const cwd = options.cwd ?? process.cwd();
+  const ttlSeconds = options.ttlSeconds ?? resolveModelsCacheTtlSeconds();
+  const allowStale = options.allowStale ?? false;
+  const { cachePath, projectPath } = await resolveCacheLocation(instanceUrl, cwd);
+  let raw;
+  try {
+    raw = await fs2.readFile(cachePath, "utf8");
+  } catch (error) {
+    const fsError = error;
+    if (fsError?.code === "ENOENT") return null;
+    console.warn(
+      `[gitlab-duo] Failed to read models cache at ${cachePath}: ${fsError?.message ?? String(error)}`
+    );
+    return null;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    console.warn(
+      `[gitlab-duo] Failed to parse models cache at ${cachePath}: ${error instanceof Error ? error.message : String(error)}`
+    );
+    return null;
+  }
+  const models = parsed.payload?.models;
+  if (!models || Object.keys(models).length === 0) return null;
+  const cachedAtMs = Date.parse(parsed.cachedAt);
+  const ageSeconds = Number.isFinite(cachedAtMs) ? Math.max(0, (Date.now() - cachedAtMs) / 1e3) : Infinity;
+  const stale = ageSeconds > ttlSeconds;
+  if (stale && !allowStale) return null;
+  return {
+    payload: parsed.payload,
+    stale,
+    cachePath,
+    projectPath
+  };
+}
+async function fetchAndCacheModels(options) {
+  const instanceUrl = normalizeInstanceUrl(options.instanceUrl);
+  const apiKey = options.apiKey.trim();
+  const cwd = options.cwd ?? process.cwd();
+  if (!apiKey) {
+    throw new Error("GITLAB_TOKEN is required for live model discovery");
+  }
+  const projectPath = await resolveProjectPath(cwd, instanceUrl);
+  if (!projectPath) {
+    throw new Error("Could not detect GitLab project from git remote");
+  }
+  const payload = await fetchModels(instanceUrl, apiKey, projectPath);
+  const { cachePath } = await resolveCacheLocation(instanceUrl, cwd, projectPath);
+  await writeCache(cachePath, payload);
+  return {
+    payload,
+    stale: false,
+    cachePath,
+    projectPath
+  };
+}
+async function fetchModels(instanceUrl, apiKey, projectPath) {
+  const details = await fetchProjectDetailsWithFallback(instanceUrl, apiKey, projectPath);
+  const namespaceId = details.namespaceId;
+  if (!namespaceId) {
+    throw new Error("Could not determine namespace ID from project");
+  }
+  const rootNamespaceId = await resolveRootNamespaceId(instanceUrl, apiKey, namespaceId);
+  const graphqlUrl = `${instanceUrl}/api/graphql`;
+  const response = await fetch(graphqlUrl, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      authorization: `Bearer ${apiKey}`
+    },
+    body: JSON.stringify({
+      query: AVAILABLE_MODELS_QUERY,
+      variables: { rootNamespaceId }
+    })
+  });
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`GraphQL request failed (${response.status}): ${text}`);
+  }
+  const result = await response.json();
+  if (result.errors?.length) {
+    throw new Error(result.errors.map((error) => error.message).join("; "));
+  }
+  const metadata = result.data?.metadata;
+  const available = result.data?.aiChatAvailableModels;
+  const defaultModel = available?.defaultModel ?? null;
+  const pinnedModel = available?.pinnedModel ?? null;
+  const selectableModels = available?.selectableModels ?? [];
+  const featureFlags = {};
+  for (const flag of metadata?.featureFlags ?? []) {
+    featureFlags[flag.name] = flag.enabled;
+  }
+  const models = {};
+  if (defaultModel?.ref) {
+    models[defaultModel.ref] = buildModelEntry(defaultModel.name || defaultModel.ref);
+  }
+  if (pinnedModel?.ref) {
+    models[pinnedModel.ref] = buildModelEntry(pinnedModel.name || pinnedModel.ref);
+  }
+  for (const model of selectableModels) {
+    if (model.ref && !models[model.ref]) {
+      models[model.ref] = buildModelEntry(model.name || model.ref);
+    }
+  }
+  if (Object.keys(models).length === 0) {
+    models[GITLAB_DUO_DEFAULT_MODEL_ID] = buildModelEntry(GITLAB_DUO_DEFAULT_MODEL_NAME);
+  }
+  return {
+    metadata: {
+      instanceUrl,
+      rootNamespaceId,
+      gitlabVersion: metadata?.version ?? null,
+      fetchedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      featureFlags,
+      defaultModel: defaultModel?.ref ?? null,
+      pinnedModel: pinnedModel?.ref ?? null
+    },
+    models,
+    available: {
+      defaultModel,
+      pinnedModel,
+      selectableModels
+    }
+  };
+}
+async function resolveCacheLocation(instanceUrl, cwd, projectPathHint) {
+  const projectPath = projectPathHint ?? await resolveProjectPath(cwd, instanceUrl);
+  const cacheDir = resolveCacheDirectory();
+  const cacheKey = `${instanceUrl}::${projectPath ?? "no-project"}`;
+  const hash = crypto.createHash("sha256").update(cacheKey).digest("hex").slice(0, 12);
+  return {
+    cachePath: path2.join(cacheDir, `gitlab-duo-models-${hash}.json`),
+    projectPath
+  };
+}
+function resolveCacheDirectory() {
+  const xdg = process.env.XDG_CACHE_HOME?.trim();
+  if (xdg) return path2.join(xdg, "opencode");
+  return path2.join(os.homedir(), ".cache", "opencode");
+}
+async function resolveProjectPath(cwd, instanceUrl) {
+  try {
+    return await detectProjectPath(cwd, instanceUrl);
+  } catch {
+    return void 0;
+  }
+}
+async function writeCache(cachePath, payload) {
+  const data = {
+    cachedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    payload
+  };
+  await fs2.mkdir(path2.dirname(cachePath), { recursive: true });
+  await fs2.writeFile(cachePath, JSON.stringify(data, null, 2) + "\n", "utf8");
+}
+function normalizeInstanceUrl(value) {
+  return value.trim().replace(/\/$/, "");
+}
+
 // src/plugin/models.ts
 async function loadGitLabModels(options = {}) {
+  const instanceUrl = resolveInstanceUrl(options.instanceUrl);
+  const apiKey = resolveApiKey(options.apiKey);
+  const cacheTtlSeconds = resolveModelsCacheTtlSeconds();
+  const cache = await loadModelsFromCache({
+    instanceUrl,
+    ttlSeconds: cacheTtlSeconds,
+    allowStale: true
+  });
+  if (cache && !cache.stale) {
+    console.log(
+      `[gitlab-duo] Loaded ${Object.keys(cache.payload.models).length} model(s) from cache ${cache.cachePath}`
+    );
+    return cache.payload.models;
+  }
+  if (apiKey) {
+    try {
+      const fetched = await fetchAndCacheModels({
+        instanceUrl,
+        apiKey
+      });
+      console.log(
+        `[gitlab-duo] Loaded ${Object.keys(fetched.payload.models).length} model(s) from GitLab API`
+      );
+      return fetched.payload.models;
+    } catch (error) {
+      console.warn(
+        `[gitlab-duo] Failed to fetch models from GitLab API: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  if (cache?.stale) {
+    console.warn(`[gitlab-duo] Using stale models cache from ${cache.cachePath}`);
+    return cache.payload.models;
+  }
   const modelsJsonPath = resolveModelsJsonPath(options.modelsPath);
+  const modelsFromFile = await loadModelsFromFile(modelsJsonPath);
+  if (modelsFromFile) return modelsFromFile;
+  return {
+    [GITLAB_DUO_DEFAULT_MODEL_ID]: buildModelEntry(GITLAB_DUO_DEFAULT_MODEL_NAME)
+  };
+}
+async function loadModelsFromFile(modelsJsonPath) {
   if (modelsJsonPath) {
     try {
-      const raw = await fs.promises.readFile(modelsJsonPath, "utf8");
+      const raw = await fs3.promises.readFile(modelsJsonPath, "utf8");
       const data = JSON.parse(raw);
       if (data.models && Object.keys(data.models).length > 0) {
         console.log(
@@ -48,28 +471,36 @@ async function loadGitLabModels(options = {}) {
       );
     }
   }
-  return {
-    [GITLAB_DUO_DEFAULT_MODEL_ID]: buildModelEntry(GITLAB_DUO_DEFAULT_MODEL_NAME)
-  };
+  return null;
 }
 function resolveModelsJsonPath(overridePath) {
   const override = typeof overridePath === "string" && overridePath.trim() ? overridePath.trim() : process.env.GITLAB_DUO_MODELS_PATH;
   if (override) {
-    const resolved = path.isAbsolute(override) ? override : path.resolve(process.cwd(), override);
-    if (fs.existsSync(resolved)) return resolved;
+    const resolved = path3.isAbsolute(override) ? override : path3.resolve(process.cwd(), override);
+    if (fs3.existsSync(resolved)) return resolved;
     console.warn(`[gitlab-duo] models.json not found at override path ${resolved}`);
     return null;
   }
   let current = process.cwd();
   while (true) {
-    const candidate = path.join(current, "models.json");
-    if (fs.existsSync(candidate)) return candidate;
-    const parent = path.dirname(current);
+    const candidate = path3.join(current, "models.json");
+    if (fs3.existsSync(candidate)) return candidate;
+    const parent = path3.dirname(current);
     if (parent === current) break;
     current = parent;
   }
   return null;
 }
+function resolveInstanceUrl(override) {
+  if (typeof override === "string" && override.trim()) return override.trim();
+  const fromEnv = process.env.GITLAB_INSTANCE_URL?.trim();
+  if (fromEnv) return fromEnv.replace(/\/$/, "");
+  return "https://gitlab.com";
+}
+function resolveApiKey(override) {
+  if (typeof override === "string" && override.trim()) return override.trim();
+  return process.env.GITLAB_TOKEN || "";
+}
 
 // src/plugin/config.ts
 async function configHook(input) {
@@ -77,8 +508,8 @@ async function configHook(input) {
   const existing = input.provider[GITLAB_DUO_PROVIDER_ID];
   const existingOptions = existing?.options ?? {};
   const providerNpm = typeof existing?.npm === "string" && existing.npm.trim() ? existing.npm : GITLAB_DUO_PROVIDER_NPM_ENTRY;
-  const apiKey = typeof existingOptions.apiKey === "string" ? existingOptions.apiKey : process.env.GITLAB_TOKEN || "";
-  const instanceUrl = typeof existingOptions.instanceUrl === "string" ? existingOptions.instanceUrl : process.env.GITLAB_INSTANCE_URL || "https://gitlab.com";
+  const apiKey = typeof existingOptions.apiKey === "string" && existingOptions.apiKey.trim() ? existingOptions.apiKey.trim() : process.env.GITLAB_TOKEN || "";
+  const instanceUrl = typeof existingOptions.instanceUrl === "string" && existingOptions.instanceUrl.trim() ? existingOptions.instanceUrl.trim() : process.env.GITLAB_INSTANCE_URL?.trim() || "https://gitlab.com";
   const systemRules = typeof existingOptions.systemRules === "string" ? existingOptions.systemRules : "";
   const systemRulesPath = typeof existingOptions.systemRulesPath === "string" ? existingOptions.systemRulesPath : "";
   const modelsPath = typeof existingOptions.modelsPath === "string" ? existingOptions.modelsPath : void 0;
@@ -101,15 +532,15 @@ async function configHook(input) {
       enableMcp,
       systemRules: mergedSystemRules || void 0
     },
-    models: await loadGitLabModels({ modelsPath })
+    models: await loadGitLabModels({ modelsPath, instanceUrl, apiKey })
   };
 }
 async function mergeSystemRules(rules, rulesPath) {
   const baseRules = rules.trim();
   if (!rulesPath) return baseRules;
-  const resolvedPath = path2.isAbsolute(rulesPath) ? rulesPath : path2.resolve(process.cwd(), rulesPath);
+  const resolvedPath = path4.isAbsolute(rulesPath) ? rulesPath : path4.resolve(process.cwd(), rulesPath);
   try {
-    const fileRules = (await fs2.promises.readFile(resolvedPath, "utf8")).trim();
+    const fileRules = (await fs4.promises.readFile(resolvedPath, "utf8")).trim();
     if (!fileRules) return baseRules;
     return baseRules ? `${baseRules}
 
@@ -122,8 +553,8 @@ ${fileRules}` : fileRules;
 
 // src/plugin/tools.ts
 import { tool } from "@opencode-ai/plugin";
-import path3 from "path";
-import fs3 from "fs";
+import path5 from "path";
+import fs5 from "fs";
 function createReadTools() {
   return {
     read_file: tool({
@@ -140,7 +571,7 @@ function createReadTools() {
           metadata: {}
         });
         try {
-          return await fs3.promises.readFile(resolvedPath, "utf8");
+          return await fs5.promises.readFile(resolvedPath, "utf8");
         } catch (error) {
           throw new Error(formatReadError(displayPath, error));
         }
@@ -165,7 +596,7 @@ function createReadTools() {
         const results = await Promise.all(
           targets.map(async (target) => {
             try {
-              const content = await fs3.promises.readFile(target.resolvedPath, "utf8");
+              const content = await fs5.promises.readFile(target.resolvedPath, "utf8");
               return [target.inputPath, { content }];
             } catch (error) {
               return [target.inputPath, { error: formatReadError(target.displayPath, error) }];
@@ -183,9 +614,9 @@ function createReadTools() {
 }
 function resolveReadPath(filePath, ctx) {
   const displayPath = filePath;
-  const resolvedPath = path3.isAbsolute(filePath) ? filePath : path3.resolve(ctx.worktree, filePath);
-  const worktreePath = path3.resolve(ctx.worktree);
-  if (resolvedPath !== worktreePath && !resolvedPath.startsWith(worktreePath + path3.sep)) {
+  const resolvedPath = path5.isAbsolute(filePath) ? filePath : path5.resolve(ctx.worktree, filePath);
+  const worktreePath = path5.resolve(ctx.worktree);
+  if (resolvedPath !== worktreePath && !resolvedPath.startsWith(worktreePath + path5.sep)) {
     throw new Error(`File is outside the repository: "${displayPath}"`);
   }
   return { resolvedPath, displayPath };
@@ -1060,7 +1491,7 @@ function classifyModeReminder2(reminder) {
 }
 
 // src/provider/application/workflow_event_mapper.ts
-import crypto from "crypto";
+import crypto2 from "crypto";
 
 // src/provider/core/ui_chat_log.ts
 import { z } from "zod";
@@ -1201,7 +1632,7 @@ var WorkflowEventMapper = class {
         break;
       }
       case "request": {
-        const requestId = latestMessage.correlation_id || crypto.randomUUID();
+        const requestId = latestMessage.correlation_id || crypto2.randomUUID();
         events.push({
           type: "TOOL_REQUEST",
           requestId,
@@ -1706,175 +2137,6 @@ function parseHttpToolOutput(output) {
 // src/provider/adapters/default_runtime_dependencies.ts
 import { ProxyAgent } from "proxy-agent";
 
-// src/provider/adapters/gitlab_utils.ts
-import fs4 from "fs/promises";
-import path4 from "path";
-async function detectProjectPath(cwd, instanceUrl) {
-  let current = cwd;
-  const instance = new URL(instanceUrl);
-  const instanceHost = instance.host;
-  const instanceBasePath = instance.pathname.replace(/\/$/, "");
-  while (true) {
-    try {
-      const config = await readGitConfig(current);
-      const url = extractGitRemoteUrl(config) || "";
-      const remote = parseRemote(url);
-      if (!remote) {
-        return void 0;
-      }
-      if (remote.host !== instanceHost) {
-        throw new Error(
-          `GitLab remote host mismatch. Expected ${instanceHost}, got ${remote.host}.`
-        );
-      }
-      return normalizeProjectPath(remote.path, instanceBasePath);
-    } catch {
-      const parent = path4.dirname(current);
-      if (parent === current) return void 0;
-      current = parent;
-    }
-  }
-}
-function extractGitRemoteUrl(config) {
-  const lines = config.split("\n");
-  let inOrigin = false;
-  let originUrl;
-  let firstUrl;
-  for (const line of lines) {
-    const trimmed = line.trim();
-    const sectionMatch = /^\[remote\s+"([^"]+)"\]$/.exec(trimmed);
-    if (sectionMatch) {
-      inOrigin = sectionMatch[1] === "origin";
-      continue;
-    }
-    const urlMatch = /^url\s*=\s*(.+)$/.exec(trimmed);
-    if (urlMatch) {
-      const value = urlMatch[1].trim();
-      if (!firstUrl) firstUrl = value;
-      if (inOrigin) originUrl = value;
-    }
-  }
-  return originUrl ?? firstUrl;
-}
-function parseRemote(remoteUrl) {
-  if (!remoteUrl) return void 0;
-  if (remoteUrl.startsWith("http")) {
-    try {
-      const url = new URL(remoteUrl);
-      return { host: url.host, path: url.pathname.replace(/^\//, "") };
-    } catch {
-      return void 0;
-    }
-  }
-  if (remoteUrl.startsWith("git@")) {
-    const match = /^git@([^:]+):(.+)$/.exec(remoteUrl);
-    if (!match) return void 0;
-    return { host: match[1], path: match[2] };
-  }
-  if (remoteUrl.startsWith("ssh://")) {
-    try {
-      const url = new URL(remoteUrl);
-      return { host: url.host, path: url.pathname.replace(/^\//, "") };
-    } catch {
-      return void 0;
-    }
-  }
-  return void 0;
-}
-function normalizeProjectPath(remotePath, instanceBasePath) {
-  let pathValue = remotePath;
-  if (instanceBasePath && instanceBasePath !== "/") {
-    const base = instanceBasePath.replace(/^\//, "") + "/";
-    if (pathValue.startsWith(base)) {
-      pathValue = pathValue.slice(base.length);
-    }
-  }
-  const cleaned = stripGitSuffix(pathValue);
-  return cleaned.length > 0 ? cleaned : void 0;
-}
-function stripGitSuffix(pathname) {
-  return pathname.endsWith(".git") ? pathname.slice(0, -4) : pathname;
-}
-function buildApiUrl(instanceUrl, apiPath) {
-  const base = instanceUrl.endsWith("/") ? instanceUrl : `${instanceUrl}/`;
-  return new URL(apiPath.replace(/^\//, ""), base).toString();
-}
-function buildAuthHeaders(apiKey) {
-  return { authorization: `Bearer ${apiKey}` };
-}
-async function fetchProjectDetails(instanceUrl, apiKey, projectPath) {
-  const url = buildApiUrl(instanceUrl, `api/v4/projects/${encodeURIComponent(projectPath)}`);
-  const response = await fetch(url, {
-    headers: buildAuthHeaders(apiKey)
-  });
-  if (!response.ok) {
-    throw new Error(`Failed to fetch project details: ${response.status}`);
-  }
-  const data = await response.json();
-  return {
-    projectId: data.id ? String(data.id) : void 0,
-    namespaceId: data.namespace?.id ? String(data.namespace.id) : void 0
-  };
-}
-async function fetchProjectDetailsWithFallback(instanceUrl, apiKey, projectPath) {
-  const candidates = getProjectPathCandidates(projectPath);
-  for (const candidate of candidates) {
-    try {
-      return await fetchProjectDetails(instanceUrl, apiKey, candidate);
-    } catch {
-      continue;
-    }
-  }
-  try {
-    const name = projectPath.split("/").pop() || projectPath;
-    const searchUrl = new URL(buildApiUrl(instanceUrl, "api/v4/projects"));
-    searchUrl.searchParams.set("search", name);
-    searchUrl.searchParams.set("simple", "true");
-    searchUrl.searchParams.set("per_page", "100");
-    searchUrl.searchParams.set("membership", "true");
-    const response = await fetch(searchUrl.toString(), {
-      headers: buildAuthHeaders(apiKey)
-    });
-    if (!response.ok) {
-      throw new Error(`Failed to search projects: ${response.status}`);
-    }
-    const data = await response.json();
-    const match = data.find((project) => project.path_with_namespace === projectPath);
-    if (!match) {
-      throw new Error("Project not found via search");
-    }
-    return {
-      projectId: match.id ? String(match.id) : void 0,
-      namespaceId: match.namespace?.id ? String(match.namespace.id) : void 0
-    };
-  } catch {
-    throw new Error("Project not found via API");
-  }
-}
-function getProjectPathCandidates(projectPath) {
-  const candidates = /* @__PURE__ */ new Set();
-  candidates.add(projectPath);
-  const parts = projectPath.split("/");
-  if (parts.length > 2) {
-    const withoutFirst = parts.slice(1).join("/");
-    candidates.add(withoutFirst);
-  }
-  return Array.from(candidates);
-}
-async function readGitConfig(cwd) {
-  const gitPath = path4.join(cwd, ".git");
-  const stat = await fs4.stat(gitPath);
-  if (stat.isDirectory()) {
-    return fs4.readFile(path4.join(gitPath, "config"), "utf8");
-  }
-  const file = await fs4.readFile(gitPath, "utf8");
-  const match = /^gitdir:\s*(.+)$/m.exec(file);
-  if (!match) throw new Error("Invalid .git file");
-  const gitdir = match[1].trim();
-  const resolved = path4.isAbsolute(gitdir) ? gitdir : path4.join(cwd, gitdir);
-  return fs4.readFile(path4.join(resolved, "config"), "utf8");
-}
-
 // src/provider/adapters/workflow_service.ts
 var WorkflowCreateError = class extends Error {
   status;
@@ -2097,10 +2359,10 @@ function buildUserAgent() {
 }
 
 // src/provider/adapters/system_context.ts
-import os from "os";
+import os2 from "os";
 function getSystemContextItems(systemRules) {
-  const platform = os.platform();
-  const arch = os.arch();
+  const platform = os2.platform();
+  const arch = os2.arch();
   const items = [
     {
       category: "os_information",
@@ -2334,24 +2596,54 @@ function assertDependencies() {
     );
   }
 }
+function resolveInstanceUrl2(value) {
+  if (typeof value === "string" && value.trim()) {
+    const normalized = value.trim();
+    assertInstanceUrl(normalized);
+    return normalized;
+  }
+  const fromEnv = process.env.GITLAB_INSTANCE_URL?.trim();
+  if (fromEnv) {
+    assertInstanceUrl(fromEnv);
+    return fromEnv;
+  }
+  return "https://gitlab.com";
+}
 function assertInstanceUrl(value) {
   try {
     new URL(value);
   } catch {
-    throw new Error(`Invalid instanceUrl: "${value}"`);
+    throw new Error(
+      `Invalid instanceUrl: "${value}". Expected an absolute URL (for example https://gitlab.com).`
+    );
   }
 }
-function createGitLabDuoAgentic(options) {
+function resolveApiKey2(value) {
+  if (typeof value === "string" && value.trim()) return value.trim();
+  return process.env.GITLAB_TOKEN || "";
+}
+function createGitLabDuoAgentic(options = {}) {
   assertDependencies();
-  assertInstanceUrl(options.instanceUrl);
+  const resolvedOptions = {
+    instanceUrl: resolveInstanceUrl2(options.instanceUrl),
+    apiKey: resolveApiKey2(options.apiKey),
+    sendSystemContext: typeof options.sendSystemContext === "boolean" ? options.sendSystemContext : true,
+    enableMcp: typeof options.enableMcp === "boolean" ? options.enableMcp : true,
+    systemRules: typeof options.systemRules === "string" ? options.systemRules : void 0
+  };
+  if (!resolvedOptions.apiKey) {
+    console.warn(
+      "[gitlab-duo] GITLAB_TOKEN is empty for the OpenCode process. Ensure it is exported in the same shell."
+    );
+  }
   const container = createRuntimeContainer();
   const dependencies = container.resolve(
     RUNTIME_TOKENS.runtimeDependencies
   );
-  const sharedRuntime = new GitLabAgenticRuntime(options, dependencies);
+  const sharedRuntime = new GitLabAgenticRuntime(resolvedOptions, dependencies);
   return {
     languageModel(modelId) {
-      return new GitLabDuoAgenticLanguageModel(modelId, options, sharedRuntime);
+      return new GitLabDuoAgenticLanguageModel(modelId, resolvedOptions, sharedRuntime);
     },
     textEmbeddingModel() {
       throw new Error("GitLab Duo Agentic does not support text embedding models");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-gitlab-duo-agentic",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "OpenCode plugin and provider for GitLab Duo Agentic workflows",
   "license": "MIT",
   "type": "module",