opencode-gitlab-duo-agentic 0.1.9 → 0.1.11

package/dist/index.d.ts

@@ -1,5 +1,9 @@
-import { Plugin } from '@opencode-ai/plugin';
+import { ProviderV2 } from '@ai-sdk/provider';
+import { Plugin, PluginInput, Hooks } from '@opencode-ai/plugin';
 
+type EntryInput = PluginInput | Record<string, unknown>;
+type EntryOutput = Promise<Hooks> | ProviderV2;
+declare const createGitLabDuoAgentic: (input: EntryInput) => EntryOutput;
 declare const GitLabDuoAgenticPlugin: Plugin;
 
-export { GitLabDuoAgenticPlugin, GitLabDuoAgenticPlugin as default };
+export { GitLabDuoAgenticPlugin, createGitLabDuoAgentic, GitLabDuoAgenticPlugin as default };

package/dist/index.js

@@ -1,14 +1,17 @@
 // src/constants.ts
-var PROVIDER_ID = "gitlab";
+var PROVIDER_ID = "gitlab-duo-agentic";
+var MODEL_ID = "duo-agentic";
 var DEFAULT_INSTANCE_URL = "https://gitlab.com";
+var AUTH_KEY_PREFIX = "gitlab-duo-v1:";
+var NOT_IMPLEMENTED_MESSAGE = "gitlab-duo-agentic is configured, but the Duo Workflow runtime is not implemented yet.";
 
-// src/gitlab.ts
+// src/utils/url.ts
 function text(value) {
   if (typeof value !== "string") return void 0;
   const trimmed = value.trim();
   return trimmed.length > 0 ? trimmed : void 0;
 }
-function instanceFromEnv() {
+function envInstanceUrl() {
   return process.env.GITLAB_INSTANCE_URL ?? process.env.GITLAB_URL ?? process.env.GITLAB_BASE_URL;
 }
 function normalizeInstanceUrl(value) {
@@ -21,6 +24,27 @@ function normalizeInstanceUrl(value) {
     return DEFAULT_INSTANCE_URL;
   }
 }
+
+// src/plugin/auth.ts
+function encodeAuthKey(value) {
+  const payload = Buffer.from(JSON.stringify(value), "utf8").toString("base64url");
+  return `${AUTH_KEY_PREFIX}${payload}`;
+}
+function decodeAuthKey(key) {
+  if (!key.startsWith(AUTH_KEY_PREFIX)) {
+    return { token: key };
+  }
+  try {
+    const payload = key.slice(AUTH_KEY_PREFIX.length);
+    const parsed = JSON.parse(Buffer.from(payload, "base64url").toString("utf8"));
+    return {
+      token: text(parsed.token),
+      instanceUrl: text(parsed.instanceUrl)
+    };
+  } catch {
+    return { token: key };
+  }
+}
 async function validateToken(instanceUrl, token) {
   const response = await fetch(`${instanceUrl}/api/v4/user`, {
     headers: {
@@ -29,38 +53,24 @@ async function validateToken(instanceUrl, token) {
   }).catch(() => void 0);
   return !!response?.ok;
 }
-async function persistInstanceUrl(input, instanceUrl) {
-  await input.client.config.update({
-    query: {
-      directory: input.directory
-    },
-    body: {
-      provider: {
-        [PROVIDER_ID]: {
-          options: {
-            instanceUrl
-          }
-        }
-      }
-    }
-  }).catch(() => void 0);
-}
-function applyGitLabConfig(config) {
-  config.provider ??= {};
-  const current = config.provider[PROVIDER_ID] ?? {};
-  const options = current.options ?? {};
-  const instanceUrl = normalizeInstanceUrl(options.instanceUrl ?? instanceFromEnv());
-  config.provider[PROVIDER_ID] = {
-    ...current,
-    options: {
-      ...options,
-      instanceUrl
-    }
-  };
-}
-function createGitLabAuthHook(input) {
+function createAuthHook() {
   return {
     provider: PROVIDER_ID,
+    loader: async (getAuth, provider) => {
+      const auth = await getAuth();
+      const decoded = auth?.type === "api" ? decodeAuthKey(auth.key) : {};
+      const options = provider.options ?? {};
+      const instanceUrl = normalizeInstanceUrl(decoded.instanceUrl ?? options.instanceUrl ?? envInstanceUrl());
+      if (!decoded.token) {
+        return {
+          instanceUrl
+        };
+      }
+      return {
+        apiKey: decoded.token,
+        instanceUrl
+      };
+    },
     methods: [
       {
         type: "api",
@@ -84,14 +94,12 @@ function createGitLabAuthHook(input) {
         authorize: async (inputs = {}) => {
           const token = text(inputs.token);
           if (!token) return { type: "failed" };
-          const instanceUrl = normalizeInstanceUrl(inputs.instanceUrl ?? instanceFromEnv());
+          const instanceUrl = normalizeInstanceUrl(inputs.instanceUrl ?? envInstanceUrl());
           const valid = await validateToken(instanceUrl, token);
           if (!valid) return { type: "failed" };
-          process.env.GITLAB_INSTANCE_URL = instanceUrl;
-          await persistInstanceUrl(input, instanceUrl);
           return {
             type: "success",
-            key: token
+            key: encodeAuthKey({ token, instanceUrl })
           };
         }
       }
@@ -99,13 +107,101 @@ function createGitLabAuthHook(input) {
   };
 }
 
+// src/plugin/config.ts
+function applyRuntimeConfig(config, moduleUrl) {
+  config.provider ??= {};
+  const current = config.provider[PROVIDER_ID] ?? {};
+  const options = current.options ?? {};
+  const models = current.models ?? {};
+  const instanceUrl = normalizeInstanceUrl(options.instanceUrl ?? envInstanceUrl());
+  config.provider[PROVIDER_ID] = {
+    ...current,
+    name: current.name ?? "GitLab Duo Agentic",
+    npm: current.npm ?? moduleUrl,
+    env: current.env ?? ["GITLAB_TOKEN", "GITLAB_INSTANCE_URL"],
+    options: {
+      ...options,
+      instanceUrl
+    },
+    models: Object.keys(models).length > 0 ? models : {
+      [MODEL_ID]: {
+        id: MODEL_ID,
+        name: "GitLab Duo Agentic (fallback)"
+      }
+    }
+  };
+  if (Array.isArray(config.disabled_providers)) {
+    config.disabled_providers = config.disabled_providers.filter((id) => id !== PROVIDER_ID);
+  }
+  if (Array.isArray(config.enabled_providers) && !config.enabled_providers.includes(PROVIDER_ID)) {
+    config.enabled_providers = [...config.enabled_providers, PROVIDER_ID];
+  }
+}
+
+// src/plugin/hooks.ts
+async function createPluginHooks(_input, moduleUrl) {
+  return {
+    config: async (config) => applyRuntimeConfig(config, moduleUrl),
+    auth: createAuthHook()
+  };
+}
+
+// src/provider/index.ts
+import { NoSuchModelError, UnsupportedFunctionalityError } from "@ai-sdk/provider";
+function notImplemented() {
+  return new UnsupportedFunctionalityError({
+    functionality: "gitlab-duo-workflow-runtime",
+    message: NOT_IMPLEMENTED_MESSAGE
+  });
+}
+function fallbackModel(modelId) {
+  return {
+    specificationVersion: "v2",
+    provider: PROVIDER_ID,
+    modelId,
+    supportedUrls: {},
+    async doGenerate(_options) {
+      throw notImplemented();
+    },
+    async doStream(_options) {
+      throw notImplemented();
+    }
+  };
+}
+function createFallbackProvider() {
+  return {
+    languageModel(modelId) {
+      if (modelId !== MODEL_ID) {
+        throw new NoSuchModelError({ modelId, modelType: "languageModel" });
+      }
+      return fallbackModel(modelId);
+    },
+    textEmbeddingModel(modelId) {
+      throw new NoSuchModelError({ modelId, modelType: "textEmbeddingModel" });
+    },
+    imageModel(modelId) {
+      throw new NoSuchModelError({ modelId, modelType: "imageModel" });
+    }
+  };
+}
+
 // src/index.ts
-var GitLabDuoAgenticPlugin = async (input) => ({
-  config: async (config) => applyGitLabConfig(config),
-  auth: createGitLabAuthHook(input)
-});
+function isPluginInput(value) {
+  if (!value || typeof value !== "object") return false;
+  const input = value;
+  return "client" in input && "project" in input && "directory" in input && "worktree" in input && "serverUrl" in input;
+}
+var entry = (input) => {
+  if (isPluginInput(input)) {
+    return createPluginHooks(input, import.meta.url);
+  }
+  return createFallbackProvider();
+};
+var createGitLabDuoAgentic = entry;
+var GitLabDuoAgenticPlugin = entry;
 var src_default = GitLabDuoAgenticPlugin;
 export {
   GitLabDuoAgenticPlugin,
+  createGitLabDuoAgentic,
   src_default as default
 };

package/package.json

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