pi-cline 0.1.0

package/README.md

@@ -0,0 +1,5 @@
+# pi-cline
+
+[![cline](https://badgen.net/static/cline/2.6.0/gray)](https://cline.bot/)
+
+Cline provider extension for [pi](https://github.com/badlogic/pi-mono).

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "pi-cline",
+  "version": "0.1.0",
+  "description": "Cline provider extension for pi",
+  "type": "module",
+  "license": "MIT",
+  "author": "sudosubin",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sudosubin/pi-frontier.git",
+    "directory": "pi-cline"
+  },
+  "keywords": [
+    "pi",
+    "pi-coding-agent",
+    "pi-package",
+    "cline"
+  ],
+  "pi": {
+    "extensions": [
+      "./src/index.ts"
+    ]
+  },
+  "files": [
+    "src/**/*.ts",
+    "README.md"
+  ],
+  "scripts": {
+    "lint": "biome check",
+    "format": "biome check --write",
+    "typecheck": "tsc",
+    "test": "tsx --test $(find test -name '*.test.ts' -o -name '*.test.mts' -o -name '*.test.js' | sort)",
+    "record:fixtures": "node --experimental-strip-types scripts/record-cline-fixtures.ts"
+  },
+  "dependencies": {
+    "openai": "^6.10.0"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.4.2",
+    "@tsconfig/strictest": "^2.0.8",
+    "@types/node": "^24.10.10",
+    "cline": "^2.7.0",
+    "tsx": "^4.20.6",
+    "typescript": "^5.9.3"
+  },
+  "peerDependencies": {
+    "@mariozechner/pi-ai": ">=0.49.0",
+    "@mariozechner/pi-coding-agent": ">=0.49.0"
+  }
+}

package/src/api/auth.ts

@@ -0,0 +1,242 @@
+import { fetchWithTimeout, safeJson } from "./http";
+
+interface ClineAuthTokenData {
+  accessToken: string;
+  refreshToken: string;
+  expiresAt: string;
+}
+
+export interface ClineAuthOrganization {
+  active: boolean;
+  memberId: string;
+  name: string;
+  organizationId: string;
+  roles: string[];
+}
+
+export interface ClineAuthUserInfo {
+  id: string;
+  email: string;
+  displayName: string;
+  createdAt: string;
+  organizations: ClineAuthOrganization[];
+  appBaseUrl?: string;
+  subject?: string;
+}
+
+interface ClineTokenEnvelope {
+  success?: boolean;
+  data?: {
+    accessToken?: string;
+    refreshToken?: string;
+    expiresAt?: string;
+  };
+  redirect_url?: string;
+}
+
+interface ClineUserEnvelope {
+  success?: boolean;
+  data?: ClineAuthUserInfo;
+}
+
+const AUTHORIZE_TIMEOUT_MS = 8000;
+const DEFAULT_REQUEST_TIMEOUT_MS = 15000;
+
+const toWorkosBearerToken = (accessToken: string): string => {
+  const normalized = accessToken.startsWith("workos:")
+    ? accessToken
+    : `workos:${accessToken}`;
+  return `Bearer ${normalized}`;
+};
+
+const trimTrailingSlashes = (value: string): string => {
+  return value.replace(/\/+$/, "");
+};
+
+export interface GetAuthorizeUrlParams {
+  callbackUrl: string;
+  headers: Record<string, string>;
+  signal?: AbortSignal;
+}
+
+export interface ExchangeAuthorizationCodeParams {
+  code: string;
+  callbackUrl: string;
+  provider: string | null;
+  headers: Record<string, string>;
+  signal?: AbortSignal;
+}
+
+export interface RefreshAccessTokenParams {
+  refreshToken: string;
+  headers: Record<string, string>;
+  signal?: AbortSignal;
+}
+
+export interface GetCurrentUserParams {
+  accessToken: string;
+  headers: Record<string, string>;
+  signal?: AbortSignal;
+}
+
+export class ClineAuthApi {
+  private readonly baseUrl: string;
+
+  constructor(baseUrl: string) {
+    this.baseUrl = trimTrailingSlashes(baseUrl);
+  }
+
+  async getAuthorizeUrl({
+    callbackUrl,
+    headers,
+    signal,
+  }: GetAuthorizeUrlParams): Promise<string> {
+    const url = this.buildApiUrl("auth/authorize");
+    url.searchParams.set("client_type", "extension");
+    url.searchParams.set("callback_url", callbackUrl);
+    url.searchParams.set("redirect_uri", callbackUrl);
+
+    try {
+      const response = await fetchWithTimeout(url, AUTHORIZE_TIMEOUT_MS, {
+        method: "GET",
+        redirect: "manual",
+        credentials: "include",
+        headers,
+        signal: signal ?? null,
+      });
+
+      if (response.status >= 300 && response.status < 400) {
+        const location = response.headers.get("Location");
+        if (location) {
+          return location;
+        }
+        throw new Error("No redirect URL found in auth response");
+      }
+
+      const payload = await safeJson<ClineTokenEnvelope>(response);
+      if (
+        typeof payload?.redirect_url === "string" &&
+        payload.redirect_url.length > 0
+      ) {
+        return payload.redirect_url;
+      }
+
+      throw new Error("Unexpected response from auth server");
+    } catch (error) {
+      throw new Error(
+        `Authentication request failed: ${error instanceof Error ? error.message : "unknown error"}`,
+      );
+    }
+  }
+
+  async exchangeAuthorizationCode({
+    code,
+    callbackUrl,
+    provider,
+    headers,
+    signal,
+  }: ExchangeAuthorizationCodeParams): Promise<ClineAuthTokenData> {
+    const response = await this.request("auth/token", {
+      method: "POST",
+      headers,
+      signal: signal ?? null,
+      body: JSON.stringify({
+        grant_type: "authorization_code",
+        code,
+        client_type: "extension",
+        redirect_uri: callbackUrl,
+        provider,
+      }),
+    });
+
+    return await this.parseTokenResponse(response, "token exchange");
+  }
+
+  async refreshAccessToken({
+    refreshToken,
+    headers,
+    signal,
+  }: RefreshAccessTokenParams): Promise<ClineAuthTokenData> {
+    const response = await this.request("auth/refresh", {
+      method: "POST",
+      headers,
+      signal: signal ?? null,
+      body: JSON.stringify({ refreshToken, grantType: "refresh_token" }),
+    });
+
+    return await this.parseTokenResponse(response, "token refresh");
+  }
+
+  async getCurrentUser({
+    accessToken,
+    headers,
+    signal,
+  }: GetCurrentUserParams): Promise<ClineAuthUserInfo> {
+    const response = await this.request("users/me", {
+      method: "GET",
+      headers: { ...headers, Authorization: toWorkosBearerToken(accessToken) },
+      signal: signal ?? null,
+    });
+
+    const payload = await safeJson<ClineUserEnvelope>(response);
+    if (!response.ok) {
+      const errorBody = payload
+        ? JSON.stringify(payload)
+        : "invalid json response";
+      throw new Error(
+        `Cline current user lookup failed: ${response.status} ${errorBody}`,
+      );
+    }
+
+    if (!payload?.data) {
+      throw new Error("Cline current user lookup returned invalid response");
+    }
+
+    return payload.data;
+  }
+
+  private buildApiUrl(path: string): URL {
+    const normalizedPath = path.replace(/^\/+/, "");
+    return new URL(normalizedPath, `${this.baseUrl}/`);
+  }
+
+  private async request(path: string, init?: RequestInit): Promise<Response> {
+    return await fetchWithTimeout(
+      this.buildApiUrl(path),
+      DEFAULT_REQUEST_TIMEOUT_MS,
+      init,
+    );
+  }
+
+  private async parseTokenResponse(
+    response: Response,
+    context: string,
+  ): Promise<ClineAuthTokenData> {
+    const payload = await safeJson<ClineTokenEnvelope>(response);
+
+    if (!response.ok) {
+      const errorBody = payload
+        ? JSON.stringify(payload)
+        : "invalid json response";
+      throw new Error(
+        `Cline ${context} failed: ${response.status} ${errorBody}`,
+      );
+    }
+
+    const data = payload?.data;
+    if (
+      !payload?.success ||
+      !data?.accessToken ||
+      !data?.refreshToken ||
+      !data.expiresAt
+    ) {
+      throw new Error(`Cline ${context} returned invalid response`);
+    }
+
+    return {
+      accessToken: data.accessToken,
+      refreshToken: data.refreshToken,
+      expiresAt: data.expiresAt,
+    };
+  }
+}

package/src/api/cline-chat.ts

@@ -0,0 +1,108 @@
+import OpenAI from "openai";
+import { APIError, APIUserAbortError } from "openai/error";
+import type {
+  ChatCompletionChunk,
+  ChatCompletionCreateParamsStreaming,
+} from "openai/resources/chat/completions";
+import { backoff } from "../lib/backoff";
+import {
+  CLINE_API_BASE_URL,
+  CLINE_REQUEST_TIMEOUT_MS,
+  CLINE_RETRY_COUNT,
+  CLINE_RETRY_DELAY_MS,
+} from "../lib/env";
+
+export interface ClineChatMessage {
+  role: "assistant" | "system" | "tool" | "user";
+  content: string | Array<{ type: "text"; text: string }>;
+}
+
+export interface ClineChatCompletionRequest {
+  model: string;
+  temperature: number;
+  messages: ClineChatMessage[];
+  stream: true;
+  stream_options: { include_usage: true };
+  include_reasoning: true;
+}
+
+export type ClineRequestHeaders = Record<string, string>;
+
+interface ClineChunkError {
+  message?: string;
+  code?: string;
+  metadata?: unknown;
+}
+
+type ClineChatCompletionChoice = Omit<
+  ChatCompletionChunk.Choice,
+  "delta" | "finish_reason"
+> & {
+  delta: ChatCompletionChunk.Choice.Delta & {
+    reasoning?: string | null;
+  };
+  finish_reason: ChatCompletionChunk.Choice["finish_reason"] | "error";
+  error?: ClineChunkError;
+};
+
+export interface ClineChatCompletionChunk extends Omit<
+  ChatCompletionChunk,
+  "choices"
+> {
+  error?: ClineChunkError;
+  choices: ClineChatCompletionChoice[];
+}
+
+export interface CreateChatCompletionStreamArgs {
+  apiKey: string;
+  headers: ClineRequestHeaders;
+  body: ClineChatCompletionRequest;
+  signal?: AbortSignal;
+}
+
+export interface ClineChatTransport {
+  createChatCompletionStream(
+    args: CreateChatCompletionStreamArgs,
+  ): Promise<AsyncIterable<ClineChatCompletionChunk>>;
+}
+
+const createClient = (apiKey: string, headers: ClineRequestHeaders) =>
+  new OpenAI({
+    apiKey,
+    baseURL: CLINE_API_BASE_URL,
+    defaultHeaders: headers,
+    maxRetries: 0,
+    timeout: CLINE_REQUEST_TIMEOUT_MS,
+  });
+
+function shouldRetryRequest(error: unknown) {
+  if (error instanceof APIUserAbortError) {
+    return false;
+  }
+
+  if (!(error instanceof APIError)) {
+    return true;
+  }
+
+  const status = error.status;
+  return status === undefined || status === 429 || status >= 500;
+}
+
+export const defaultClineChatTransport: ClineChatTransport = {
+  async createChatCompletionStream({ apiKey, body, headers, signal }) {
+    return backoff(
+      async () => {
+        const client = createClient(apiKey, headers);
+        return await client.chat.completions.create(
+          body as ChatCompletionCreateParamsStreaming,
+          { signal, maxRetries: 0, timeout: CLINE_REQUEST_TIMEOUT_MS },
+        );
+      },
+      {
+        retries: CLINE_RETRY_COUNT,
+        delayMs: CLINE_RETRY_DELAY_MS,
+        shouldRetry: (error) => !signal?.aborted && shouldRetryRequest(error),
+      },
+    );
+  },
+};

package/src/api/http.ts

@@ -0,0 +1,26 @@
+export const fetchWithTimeout = async (
+  input: string | URL,
+  timeoutMs: number,
+  init?: RequestInit,
+): Promise<Response> => {
+  const timeoutController = new AbortController();
+  const timeout = setTimeout(() => timeoutController.abort(), timeoutMs);
+
+  const signal = init?.signal
+    ? AbortSignal.any([init.signal, timeoutController.signal])
+    : timeoutController.signal;
+
+  try {
+    return await fetch(input, { ...init, signal });
+  } finally {
+    clearTimeout(timeout);
+  }
+};
+
+export const safeJson = async <T>(response: Response): Promise<T | null> => {
+  try {
+    return (await response.json()) as T;
+  } catch {
+    return null;
+  }
+};

package/src/api/recommended-models.ts

@@ -0,0 +1,43 @@
+import { backoff } from "../lib/backoff";
+import {
+  CLINE_RECOMMENDED_MODELS_URL,
+  CLINE_RETRY_COUNT,
+  CLINE_RETRY_DELAY_MS,
+} from "../lib/env";
+
+export interface ClineRecommendedModel {
+  id: string;
+  name: string;
+  description: string;
+  tags: string[];
+}
+
+export interface ClineRecommendedModelsData {
+  recommended: ClineRecommendedModel[];
+  free: ClineRecommendedModel[];
+}
+
+export async function fetchRecommendedModels(): Promise<ClineRecommendedModelsData> {
+  return backoff(
+    async () => {
+      const response = await fetch(CLINE_RECOMMENDED_MODELS_URL, {
+        method: "GET",
+        headers: { Accept: "application/json" },
+      });
+
+      if (!response.ok) {
+        throw new Error(
+          `Recommended models request failed: ${response.status} ${response.statusText}`,
+        );
+      }
+
+      const models = (await response.json()) as ClineRecommendedModelsData;
+      if (!models || !models.free) {
+        throw new Error("Invalid recommended models response");
+      }
+
+      return models;
+    },
+    { retries: CLINE_RETRY_COUNT, delayMs: CLINE_RETRY_DELAY_MS },
+  );
+}