opencode-kilocode-auth 1.0.0

package/src/plugin/types.ts

@@ -0,0 +1,121 @@
+/**
+ * Types for the Kilo Code OpenCode plugin
+ */
+
+export interface KilocodeAuthDetails {
+  type: "kilocode";
+  token: string;
+  organizationId?: string;
+  model?: string;
+  userEmail?: string;
+}
+
+export interface NonKilocodeAuthDetails {
+  type: string;
+  [key: string]: unknown;
+}
+
+export type AuthDetails = KilocodeAuthDetails | NonKilocodeAuthDetails;
+
+export type GetAuth = () => Promise<AuthDetails>;
+
+export interface ProviderModel {
+  cost?: {
+    input: number;
+    output: number;
+  };
+  [key: string]: unknown;
+}
+
+export interface Provider {
+  models?: Record<string, ProviderModel>;
+  options?: Record<string, unknown>;
+}
+
+export interface LoaderResult {
+  apiKey: string;
+  fetch(input: RequestInfo, init?: RequestInit): Promise<Response>;
+}
+
+export interface DeviceAuthInitiateResponse {
+  code: string;
+  verificationUrl: string;
+  expiresIn: number;
+}
+
+export interface DeviceAuthPollResponse {
+  status: "pending" | "approved" | "denied" | "expired";
+  token?: string;
+  userEmail?: string;
+}
+
+export interface KilocodeOrganization {
+  id: string;
+  name: string;
+  role: string;
+}
+
+export interface KilocodeProfileData {
+  id: string;
+  email: string;
+  name?: string;
+  organizations?: KilocodeOrganization[];
+}
+
+export interface ModelInfo {
+  id: string;
+  name: string;
+  displayName?: string;
+  contextWindow: number;
+  maxTokens?: number;
+  supportsImages?: boolean;
+  inputPrice?: number;
+  outputPrice?: number;
+  description?: string;
+  preferredIndex?: number;
+}
+
+export interface KilocodeAuthResult {
+  type: "success";
+  token: string;
+  userEmail?: string;
+  organizationId?: string;
+  model?: string;
+}
+
+export interface KilocodeAuthFailed {
+  type: "failed";
+  error: string;
+}
+
+export type KilocodeTokenExchangeResult = KilocodeAuthResult | KilocodeAuthFailed;
+
+export interface AuthMethod {
+  provider?: string;
+  label: string;
+  type: "oauth" | "api" | "device";
+  authorize?: () => Promise<{
+    url: string;
+    instructions: string;
+    method: string;
+    callback: (() => Promise<KilocodeTokenExchangeResult>) | ((input: string) => Promise<KilocodeTokenExchangeResult>);
+  }>;
+}
+
+export interface PluginClient {
+  auth: {
+    set(input: { path: { id: string }; body: KilocodeAuthDetails }): Promise<void>;
+  };
+}
+
+export interface PluginContext {
+  client: PluginClient;
+}
+
+export interface PluginResult {
+  auth: {
+    provider: string;
+    loader: (getAuth: GetAuth, provider: Provider) => Promise<LoaderResult | null>;
+    methods: AuthMethod[];
+  };
+}

package/src/plugin.ts

@@ -0,0 +1,231 @@
+import type { Hooks, PluginInput } from "@opencode-ai/plugin"
+import {
+  KILOCODE_PROVIDER_ID,
+  KILOCODE_API_BASE_URL,
+  DEFAULT_HEADERS,
+  DEFAULT_MODEL_ID,
+  DEVICE_AUTH_POLL_INTERVAL_MS,
+} from "./constants"
+import {
+  initiateDeviceAuth,
+  pollDeviceAuth,
+  getKilocodeProfile,
+  getKilocodeDefaultModel,
+  getKilocodeModels,
+  openBrowserUrl,
+  getApiUrl,
+} from "./kilocode/auth"
+
+interface KilocodeAuth {
+  type: "oauth"
+  refresh: string // token
+  access?: string
+  expires?: number
+  organizationId?: string
+  model?: string
+}
+
+/**
+ * Kilo Code Authentication Plugin for OpenCode
+ *
+ * Provides authentication with Kilo Code API and access to 300+ AI models
+ * including the free Giga Potato model optimized for agentic programming.
+ */
+export async function KilocodeAuthPlugin(input: PluginInput): Promise<Hooks> {
+  const sdk = input.client
+
+  return {
+    auth: {
+      provider: KILOCODE_PROVIDER_ID,
+
+      async loader(getAuth, provider) {
+        const auth = await getAuth()
+        if (!auth || auth.type !== "oauth") return {}
+
+        const kilocodeAuth = auth as KilocodeAuth
+        const token = kilocodeAuth.refresh
+
+        if (!token) return {}
+
+        // Get model from config or auth
+        const modelFromAuth = kilocodeAuth.model || DEFAULT_MODEL_ID
+
+        // Set costs to 0 for all models (Kilo Code handles billing)
+        if (provider && provider.models) {
+          for (const model of Object.values(provider.models)) {
+            if (model) {
+              model.cost = {
+                input: 0,
+                output: 0,
+                cache: { read: 0, write: 0 },
+              }
+            }
+          }
+        }
+
+        // Build base URL for OpenRouter-compatible API
+        const baseURL = getApiUrl("/api/openrouter/v1", token)
+
+        return {
+          baseURL,
+          apiKey: token,
+
+          async fetch(requestInput: RequestInfo | URL, init?: RequestInit) {
+            const currentAuth = await getAuth()
+            if (!currentAuth || currentAuth.type !== "oauth") {
+              return fetch(requestInput, init)
+            }
+
+            const currentKilocodeAuth = currentAuth as KilocodeAuth
+            const currentToken = currentKilocodeAuth.refresh
+
+            // Build headers
+            const headers = new Headers()
+            if (init?.headers) {
+              if (init.headers instanceof Headers) {
+                init.headers.forEach((value, key) => headers.set(key, value))
+              } else if (Array.isArray(init.headers)) {
+                for (const [key, value] of init.headers) {
+                  if (value !== undefined) headers.set(key, String(value))
+                }
+              } else {
+                for (const [key, value] of Object.entries(init.headers)) {
+                  if (value !== undefined) headers.set(key, String(value))
+                }
+              }
+            }
+
+            // Set Kilo Code authorization
+            headers.set("Authorization", `Bearer ${currentToken}`)
+            headers.set("X-KILOCODE-EDITORNAME", "opencode")
+
+            // Add organization header if present
+            if (currentKilocodeAuth.organizationId) {
+              headers.set("X-KILOCODE-ORGANIZATIONID", currentKilocodeAuth.organizationId)
+            }
+
+            // Rewrite URL to Kilo Code endpoint
+            const parsed =
+              requestInput instanceof URL
+                ? requestInput
+                : new URL(typeof requestInput === "string" ? requestInput : (requestInput as Request).url)
+
+            // Map to Kilo Code OpenRouter-compatible endpoint
+            let url: URL
+            if (parsed.pathname.includes("/chat/completions") || parsed.pathname.includes("/v1/chat/completions")) {
+              url = new URL(getApiUrl("/api/openrouter/v1/chat/completions", currentToken))
+            } else if (parsed.pathname.includes("/models")) {
+              url = new URL(getApiUrl("/api/openrouter/models", currentToken))
+            } else {
+              url = new URL(getApiUrl(`/api/openrouter${parsed.pathname}`, currentToken))
+            }
+
+            return fetch(url, {
+              ...init,
+              headers,
+            })
+          },
+        }
+      },
+
+      methods: [
+        {
+          type: "oauth",
+          label: "Login with Kilo Code",
+          async authorize() {
+            // Initiate device auth flow
+            const authData = await initiateDeviceAuth()
+            const { code, verificationUrl, expiresIn } = authData
+
+            // Open browser for user
+            openBrowserUrl(verificationUrl)
+
+            return {
+              url: verificationUrl,
+              instructions: `Enter code: ${code}`,
+              method: "auto" as const,
+
+              async callback() {
+                // Poll for authorization
+                const maxAttempts = Math.ceil((expiresIn * 1000) / DEVICE_AUTH_POLL_INTERVAL_MS)
+                let attempt = 0
+
+                while (attempt < maxAttempts) {
+                  await new Promise((resolve) => setTimeout(resolve, DEVICE_AUTH_POLL_INTERVAL_MS))
+
+                  try {
+                    const pollResult = await pollDeviceAuth(code)
+
+                    if (pollResult.status === "approved" && pollResult.token) {
+                      // Get profile for organization
+                      let organizationId: string | undefined
+                      try {
+                        const profile = await getKilocodeProfile(pollResult.token)
+                        if (profile.organizations && profile.organizations.length > 0) {
+                          organizationId = profile.organizations[0].id
+                        }
+                      } catch {
+                        // Continue without organization
+                      }
+
+                      // Get default model
+                      const model = await getKilocodeDefaultModel(pollResult.token, organizationId)
+
+                      return {
+                        type: "success" as const,
+                        refresh: pollResult.token,
+                        access: pollResult.token,
+                        expires: Date.now() + 365 * 24 * 60 * 60 * 1000, // 1 year (tokens don't expire normally)
+                        // Store extra info in the auth
+                        organizationId,
+                        model,
+                      } as any
+                    }
+
+                    if (pollResult.status === "denied") {
+                      return { type: "failed" as const }
+                    }
+
+                    if (pollResult.status === "expired") {
+                      return { type: "failed" as const }
+                    }
+                  } catch {
+                    // Continue polling on error
+                  }
+
+                  attempt++
+                }
+
+                return { type: "failed" as const }
+              },
+            }
+          },
+        },
+        {
+          type: "api",
+          label: "Enter Kilo Code API Token",
+        },
+      ],
+    },
+
+    // Add custom headers for Kilo Code requests
+    "chat.headers": async (input, output) => {
+      if (input.model.providerID !== KILOCODE_PROVIDER_ID) return
+
+      output.headers["X-KILOCODE-EDITORNAME"] = "opencode"
+      output.headers["X-KILOCODE-SESSIONID"] = input.sessionID
+    },
+  }
+}
+
+// Export utilities for external use
+export {
+  initiateDeviceAuth,
+  pollDeviceAuth,
+  getKilocodeProfile,
+  getKilocodeDefaultModel,
+  getKilocodeModels,
+  getApiUrl,
+}
+
+export type { KilocodeAuth }