@cerebriline/core 4.100.240

package/dist/auth/cline.d.ts

@@ -0,0 +1,71 @@
+import { type ITelemetryService } from "@cerebriline/shared";
+import type { OAuthCredentials, OAuthLoginCallbacks } from "./types";
+export type ClineTokenResolution = {
+    forceRefresh?: boolean;
+    refreshBufferMs?: number;
+    retryableTokenGraceMs?: number;
+};
+interface ClineAuthApiUser {
+    subject: string | null;
+    email: string;
+    name: string;
+    clineUserId: string | null;
+    accounts: string[] | null;
+}
+type HeaderMap = Record<string, string>;
+type HeaderInput = HeaderMap | (() => Promise<HeaderMap> | HeaderMap);
+export interface ClineOAuthProviderOptions {
+    apiBaseUrl: string;
+    headers?: HeaderInput;
+    requestTimeoutMs?: number;
+    telemetry?: ITelemetryService;
+    useWorkOSDeviceAuth?: boolean;
+    callbackPath?: string;
+    callbackPorts?: number[];
+    /**
+     * Optional identity provider name for token exchange.
+     */
+    provider?: string;
+}
+export interface ClineOAuthCredentials extends OAuthCredentials {
+    metadata?: {
+        provider?: string;
+        tokenType?: string;
+        userInfo?: ClineAuthApiUser;
+        [key: string]: unknown;
+    };
+}
+export declare function loginClineOAuth(options: ClineOAuthProviderOptions & {
+    callbacks: OAuthLoginCallbacks;
+}): Promise<ClineOAuthCredentials>;
+export declare function startClineDeviceAuth(options?: {
+    requestTimeoutMs?: number;
+}): Promise<{
+    deviceCode: string;
+    userCode: string;
+    verificationUri: string;
+    verificationUriComplete?: string;
+    expiresInSeconds: number;
+    pollIntervalSeconds: number;
+}>;
+export declare function completeClineDeviceAuth(options: {
+    deviceCode: string;
+    expiresInSeconds: number;
+    pollIntervalSeconds: number;
+    apiBaseUrl: string;
+    provider?: string;
+    headers?: HeaderInput;
+    requestTimeoutMs?: number;
+    telemetry?: ITelemetryService;
+}): Promise<ClineOAuthCredentials>;
+export declare function refreshClineToken(current: ClineOAuthCredentials, options: ClineOAuthProviderOptions): Promise<ClineOAuthCredentials>;
+/**
+ * Resolve valid Cline credentials, refreshing when needed.
+ *
+ * Contract: returns refreshed/current credentials when usable; returns `null`
+ * ONLY when the refresh token was rejected (invalid grant — re-auth required);
+ * THROWS on transient failures (network, timeout, 5xx) so callers can leave
+ * stored credentials untouched and retry later.
+ */
+export declare function getValidClineCredentials(currentCredentials: ClineOAuthCredentials | null, providerOptions: ClineOAuthProviderOptions, options?: ClineTokenResolution): Promise<ClineOAuthCredentials | null>;
+export {};

package/dist/auth/codex.d.ts

@@ -0,0 +1,40 @@
+/**
+ * OpenAI Codex (ChatGPT OAuth) flow
+ *
+ * NOTE: This module uses Node.js crypto and http for the OAuth callback.
+ * It is only intended for CLI use, not browser environments.
+ */
+import { type ITelemetryService } from "@cerebriline/shared";
+import type { OAuthCredentials, OAuthPrompt } from "./types";
+export declare const OPENAI_CODEX_OAUTH_CONFIG: {
+    readonly authorizationEndpoint: "https://auth.openai.com/oauth/authorize";
+    readonly tokenEndpoint: "https://auth.openai.com/oauth/token";
+    readonly clientId: "app_EMoamEEZ73f0CkXaXp7hrann";
+    readonly redirectUri: "http://localhost:1455/auth/callback";
+    readonly scopes: "openid profile email offline_access";
+    readonly callbackPort: 1455;
+    readonly jwtClaimPath: "https://api.openai.com/auth";
+    readonly refreshBufferMs: number;
+    readonly retryableTokenGraceMs: number;
+    readonly httpTimeoutMs: number;
+};
+export type RefreshTokenResolution = {
+    forceRefresh?: boolean;
+    refreshBufferMs?: number;
+    retryableTokenGraceMs?: number;
+};
+export declare function loginOpenAICodex(options: {
+    onAuth: (info: {
+        url: string;
+        instructions?: string;
+    }) => void;
+    onPrompt: (prompt: OAuthPrompt) => Promise<string>;
+    onProgress?: (message: string) => void;
+    onManualCodeInput?: () => Promise<string>;
+    originator?: string;
+    telemetry?: ITelemetryService;
+}): Promise<OAuthCredentials>;
+export declare function refreshOpenAICodexToken(refreshToken: string, fallback?: OAuthCredentials): Promise<OAuthCredentials>;
+export declare function getValidOpenAICodexCredentials(currentCredentials: OAuthCredentials | null, options?: RefreshTokenResolution & {
+    telemetry?: ITelemetryService;
+}): Promise<OAuthCredentials | null>;

package/dist/auth/oca.d.ts

@@ -0,0 +1,21 @@
+import { type ITelemetryService } from "@cerebriline/shared";
+import type { OAuthCredentials, OAuthLoginCallbacks, OcaOAuthProviderOptions, OcaTokenResolution } from "./types";
+export declare const DEFAULT_INTERNAL_IDCS_CLIENT_ID = "a8331954c0cf48ba99b5dd223a14c6ea";
+export declare const DEFAULT_INTERNAL_IDCS_URL = "https://idcs-9dc693e80d9b469480d7afe00e743931.identity.oraclecloud.com";
+export declare const DEFAULT_INTERNAL_IDCS_SCOPES = "openid offline_access";
+export declare const DEFAULT_INTERNAL_OCA_BASE_URL = "https://code-internal.aiservice.us-chicago-1.oci.oraclecloud.com/20250206/app/litellm";
+export declare const DEFAULT_EXTERNAL_IDCS_CLIENT_ID = "c1aba3deed5740659981a752714eba33";
+export declare const DEFAULT_EXTERNAL_IDCS_URL = "https://login-ext.identity.oraclecloud.com";
+export declare const DEFAULT_EXTERNAL_IDCS_SCOPES = "openid offline_access";
+export declare const DEFAULT_EXTERNAL_OCA_BASE_URL = "https://code.aiservice.us-chicago-1.oci.oraclecloud.com/20250206/app/litellm";
+export declare const OCI_HEADER_OPC_REQUEST_ID = "opc-request-id";
+export declare function loginOcaOAuth(options: OcaOAuthProviderOptions & {
+    callbacks: OAuthLoginCallbacks;
+    telemetry?: ITelemetryService;
+}): Promise<OAuthCredentials>;
+export declare function refreshOcaToken(credentials: OAuthCredentials, options?: OcaOAuthProviderOptions): Promise<OAuthCredentials>;
+export declare function getValidOcaCredentials(currentCredentials: OAuthCredentials | null, options?: OcaTokenResolution & {
+    telemetry?: ITelemetryService;
+}, providerOptions?: OcaOAuthProviderOptions & {
+    telemetry?: ITelemetryService;
+}): Promise<OAuthCredentials | null>;

package/dist/auth/provider-auth-registry.d.ts

@@ -0,0 +1,52 @@
+import { type ITelemetryService } from "@cerebriline/shared";
+import type { ProviderSettingsManager } from "../services/storage/provider-settings-manager";
+import type { ProviderSettings } from "../types/provider-settings";
+import type { OAuthCredentials, OAuthLoginCallbacks } from "./types";
+export type ProviderOAuthCredentials = OAuthCredentials;
+export interface ProviderAuthLoginInput {
+    settings?: ProviderSettings;
+    callbacks: OAuthLoginCallbacks;
+    telemetry?: ITelemetryService;
+}
+export interface ProviderAuthRefreshInput {
+    settings: ProviderSettings;
+    credentials: ProviderOAuthCredentials;
+    forceRefresh?: boolean;
+    telemetry?: ITelemetryService;
+}
+export interface ProviderAuthSaveCredentialsInput {
+    manager: ProviderSettingsManager;
+    settings?: ProviderSettings;
+    credentials: ProviderOAuthCredentials;
+    setLastUsed?: boolean;
+    save?: boolean;
+}
+export interface ProviderAuthHandler {
+    providerId: string;
+    storageProviderId: string;
+    getApiKey(settings: ProviderSettings | undefined): string | undefined;
+    login(input: ProviderAuthLoginInput): Promise<ProviderOAuthCredentials>;
+    refresh(input: ProviderAuthRefreshInput): Promise<ProviderOAuthCredentials | null>;
+    saveCredentials(input: ProviderAuthSaveCredentialsInput): ProviderSettings;
+    isConfigured(settings: ProviderSettings | undefined): boolean;
+    normalizeStoredAccessToken?(accessToken: string): string;
+}
+export declare function getProviderAuthHandler(providerId: string): ProviderAuthHandler | undefined;
+export declare function isOAuthProvider(providerId: string): boolean;
+export declare function getProviderAuthStorageId(providerId: string): string | undefined;
+export declare function resolveProviderApiKeyFromSettings(manager: ProviderSettingsManager, providerId: string): string | undefined;
+export declare function loginAndSaveProviderOAuthCredentials(manager: ProviderSettingsManager, providerId: string, input: {
+    callbacks: OAuthLoginCallbacks;
+    telemetry?: ITelemetryService;
+}): Promise<ProviderSettings>;
+export declare function getProviderOAuthCredentialsFromSettings(providerId: string, settings: ProviderSettings): ProviderOAuthCredentials | null;
+export declare function saveProviderOAuthCredentials(input: {
+    manager: ProviderSettingsManager;
+    providerId: string;
+    settings?: ProviderSettings;
+    credentials: ProviderOAuthCredentials;
+    setLastUsed?: boolean;
+    save?: boolean;
+}): ProviderSettings;
+export declare function getPersistedProviderApiKey(providerId: string, settings?: ProviderSettings): string | undefined;
+export declare function formatProviderOAuthApiKey(providerId: string, credentials: Pick<ProviderOAuthCredentials, "access">): string;

package/dist/auth/server.d.ts

@@ -0,0 +1,54 @@
+export interface OAuthCallbackPayload {
+    url: URL;
+    code?: string;
+    state?: string;
+    provider?: string;
+    error?: string;
+}
+export interface OAuthServerListeningInfo {
+    host: string;
+    port: number;
+    callbackUrl: string;
+}
+export interface OAuthServerCloseInfo {
+    host: string;
+    port: number;
+}
+export interface LocalOAuthServerOptions {
+    host?: string;
+    ports: number[];
+    callbackPath: string;
+    timeoutMs?: number;
+    expectedState?: string;
+    successHtml?: string;
+    /**
+     * Called when the local redirect server successfully binds to a port and is
+     * ready to receive the OAuth callback. Hosts can use this to display a
+     * "waiting for callback" status indicator or — in remote-development
+     * environments like JetBrains Gateway — to forward the port from the remote
+     * machine to the local machine where the user's browser is running.
+     *
+     * May be async; `startLocalOAuthServer` will **await** this callback before
+     * returning so that any setup it performs (e.g. port-forwarding) is
+     * guaranteed to complete before the caller opens the auth URL. Errors
+     * thrown by this callback are swallowed — they do not prevent the OAuth
+     * flow from proceeding.
+     */
+    onListening?: (info: OAuthServerListeningInfo) => void | Promise<void>;
+    /**
+     * Called when the local redirect server closes, either because the OAuth
+     * callback was received, the flow was cancelled, or the timeout elapsed.
+     * Hosts should use this to tear down any port-forward set up in
+     * `onListening` and clear any "waiting for callback" status UI.
+     *
+     * May be async; fired after the underlying server socket is closed.
+     */
+    onClose?: (info: OAuthServerCloseInfo) => void | Promise<void>;
+}
+export interface LocalOAuthServer {
+    callbackUrl: string;
+    waitForCallback: () => Promise<OAuthCallbackPayload | null>;
+    cancelWait: () => void;
+    close: () => void;
+}
+export declare function startLocalOAuthServer(options: LocalOAuthServerOptions): Promise<LocalOAuthServer>;

package/dist/auth/types.d.ts

@@ -0,0 +1,103 @@
+import type { ITelemetryService } from "@cerebriline/shared";
+import type { OAuthServerCloseInfo, OAuthServerListeningInfo } from "./server";
+export interface OAuthPrompt {
+    message: string;
+    defaultValue?: string;
+}
+export interface OAuthCredentials {
+    access: string;
+    refresh: string;
+    /**
+     * Expiration timestamp in milliseconds since epoch.
+     */
+    expires: number;
+    /**
+     * Optional provider-specific account identifier.
+     */
+    accountId?: string;
+    /**
+     * Optional email for display/telemetry.
+     */
+    email?: string;
+    /**
+     * Provider-specific metadata (user info, provider hint, etc).
+     */
+    metadata?: Record<string, unknown>;
+}
+export interface OAuthLoginCallbacks {
+    onAuth: (info: {
+        url: string;
+        instructions?: string;
+    }) => void;
+    onPrompt: (prompt: OAuthPrompt) => Promise<string>;
+    onProgress?: (message: string) => void;
+    onManualCodeInput?: () => Promise<string>;
+    /**
+     * Called when the local OAuth redirect server successfully binds to a port
+     * and is ready to receive the browser callback. The `info` object contains
+     * the host, the bound port number, and the full `callbackUrl`.
+     *
+     * Use this to:
+     * - Show a "waiting for OAuth callback on port N" status indicator in your UI.
+     * - Forward the port in remote-development environments (e.g. JetBrains
+     *   Gateway) from the remote machine to the machine running the browser.
+     *
+     * Paired with `onServerClose` for teardown.
+     *
+     * Only fired when the provider uses a local callback server
+     * (`OAuthProviderInterface.usesCallbackServer === true`).
+     */
+    onServerListening?: (info: OAuthServerListeningInfo) => void | Promise<void>;
+    /**
+     * Called when the local OAuth redirect server closes — either because the
+     * callback was received, the flow was cancelled, or the timeout elapsed.
+     *
+     * Use this to:
+     * - Clear any "waiting for callback" status UI shown in `onServerListening`.
+     * - Tear down port-forwards set up in `onServerListening`.
+     *
+     * Only fired when the provider uses a local callback server
+     * (`OAuthProviderInterface.usesCallbackServer === true`).
+     */
+    onServerClose?: (info: OAuthServerCloseInfo) => void | Promise<void>;
+}
+export interface OAuthProviderInterface {
+    id: string;
+    name: string;
+    usesCallbackServer: boolean;
+    login(callbacks: OAuthLoginCallbacks): Promise<OAuthCredentials>;
+    refreshToken(credentials: OAuthCredentials): Promise<OAuthCredentials>;
+    getApiKey(credentials: OAuthCredentials): string;
+}
+export type OcaMode = "internal" | "external";
+export interface OcaOAuthEnvironmentConfig {
+    clientId: string;
+    idcsUrl: string;
+    scopes: string;
+    baseUrl: string;
+}
+export interface OcaOAuthConfig {
+    internal: OcaOAuthEnvironmentConfig;
+    external: OcaOAuthEnvironmentConfig;
+}
+export interface OcaClientMetadata {
+    client?: string;
+    clientVersion?: string;
+    clientIde?: string;
+    clientIdeVersion?: string;
+}
+export interface OcaOAuthProviderOptions {
+    config?: Partial<OcaOAuthConfig>;
+    mode?: OcaMode | (() => OcaMode);
+    callbackPath?: string;
+    callbackPorts?: number[];
+    requestTimeoutMs?: number;
+    refreshBufferMs?: number;
+    retryableTokenGraceMs?: number;
+    telemetry?: ITelemetryService;
+}
+export interface OcaTokenResolution {
+    forceRefresh?: boolean;
+    refreshBufferMs?: number;
+    retryableTokenGraceMs?: number;
+}

package/dist/auth/utils.d.ts

@@ -0,0 +1,31 @@
+import type { OAuthCallbackPayload } from "./server";
+import type { OAuthCredentials } from "./types";
+export declare function getProofKey(): Promise<{
+    verifier: string;
+    challenge: string;
+}>;
+export declare function normalizeBaseUrl(value: string): string;
+export declare function resolveUrl(baseUrl: string, path: string): string;
+export type ParsedAuthorizationInput = {
+    code?: string;
+    state?: string;
+    provider?: string;
+};
+export type ParseAuthorizationInputOptions = {
+    includeProvider?: boolean;
+    allowHashCodeState?: boolean;
+};
+export declare function parseAuthorizationInput(input: string, options?: ParseAuthorizationInputOptions): ParsedAuthorizationInput;
+export declare function parseOAuthError(text: string): {
+    code?: string;
+    message?: string;
+};
+export declare function isCredentialLikelyExpired(credentials: Pick<OAuthCredentials, "expires">, refreshBufferMs: number): boolean;
+export declare function resolveAuthorizationCodeInput(input: {
+    waitForCallback: () => Promise<OAuthCallbackPayload | null>;
+    cancelWait: () => void;
+    onManualCodeInput?: () => Promise<string>;
+    parseOptions?: ParseAuthorizationInputOptions;
+}): Promise<ParsedAuthorizationInput & {
+    error?: string;
+}>;

package/dist/cline-core/automation.d.ts

@@ -0,0 +1,34 @@
+import type { AutomationEventEnvelope, BasicLogger, ExtensionContext, ITelemetryService } from "@cerebriline/shared";
+import type { CronService } from "../cron/service/cron-service";
+import type { HubScheduleRuntimeHandlers } from "../cron/service/schedule-service";
+import type { RuntimeHost } from "../runtime/host/runtime-host";
+import type { ClineAutomationEventIngressResult, ClineAutomationEventLog, ClineAutomationListEventsOptions, ClineAutomationListRunsOptions, ClineAutomationListSpecsOptions, ClineAutomationRun, ClineAutomationSpec, ClineCoreAutomationApi, ClineCoreAutomationOptions } from "./types";
+export declare function normalizeAutomationOptions(options: ClineCoreAutomationOptions | boolean | undefined): ClineCoreAutomationOptions | undefined;
+export declare function normalizeAutomationCronScope(scope: ClineCoreAutomationOptions["cronScope"]): "global" | "workspace" | undefined;
+export declare class ClineCoreAutomationController implements ClineCoreAutomationApi {
+    private readonly getService;
+    constructor(getService: () => CronService);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    reconcileNow(): Promise<void>;
+    ingestEvent(event: AutomationEventEnvelope): ClineAutomationEventIngressResult;
+    listEvents(options?: ClineAutomationListEventsOptions): ClineAutomationEventLog[];
+    getEvent(eventId: string): ClineAutomationEventLog | undefined;
+    listSpecs(options?: ClineAutomationListSpecsOptions): ClineAutomationSpec[];
+    listRuns(options?: ClineAutomationListRunsOptions): ClineAutomationRun[];
+}
+export interface ClineCoreAutomationRuntimeHandlersInput {
+    host: RuntimeHost;
+    getExtensionContext(): ExtensionContext | undefined;
+}
+export declare function createClineCoreAutomationRuntimeHandlers(input: ClineCoreAutomationRuntimeHandlersInput): HubScheduleRuntimeHandlers;
+export interface ClineCoreAutomationExtensionContextInput {
+    automationService?: CronService;
+    automation: ClineCoreAutomationApi;
+    context?: ExtensionContext;
+    clientName?: string;
+    distinctId?: string;
+    logger?: BasicLogger;
+    telemetry?: ITelemetryService;
+}
+export declare function createClineCoreAutomationExtensionContext(input: ClineCoreAutomationExtensionContextInput): ExtensionContext | undefined;

package/dist/cline-core/runtime-services.d.ts

@@ -0,0 +1,5 @@
+import type { PendingPromptsRuntimeService, PendingPromptsServiceApi, RuntimeHost, SessionConnectionRuntimeService, SessionModelRuntimeService, SessionUsageRuntimeService } from "../runtime/host/runtime-host";
+import { type ClineCoreSettingsApi } from "../settings";
+export type RuntimeHostServiceExtensions = RuntimeHost & Partial<PendingPromptsRuntimeService & SessionUsageRuntimeService & SessionConnectionRuntimeService & SessionModelRuntimeService>;
+export declare function createClineCoreSettingsApi(host: RuntimeHost): ClineCoreSettingsApi;
+export declare function createClineCorePendingPromptsApi(host: RuntimeHost): PendingPromptsServiceApi;

package/dist/cline-core/start-input.d.ts

@@ -0,0 +1,10 @@
+import type { ExtensionContext } from "@cerebriline/shared";
+import type { RuntimeCapabilities } from "../runtime/capabilities";
+import type { StartSessionInput } from "../runtime/host/runtime-host";
+import type { ClineCoreStartInput } from "./types";
+export declare function toClineCoreStartInput(input: StartSessionInput | ClineCoreStartInput): ClineCoreStartInput;
+export interface NormalizeClineCoreStartInputOptions {
+    defaultCapabilities?: RuntimeCapabilities;
+    withExtensionContext?: (context?: ExtensionContext) => ExtensionContext | undefined;
+}
+export declare function normalizeClineCoreStartInput(input: ClineCoreStartInput, options?: NormalizeClineCoreStartInputOptions): StartSessionInput;

package/dist/cline-core/telemetry.d.ts

@@ -0,0 +1,10 @@
+import type { ITelemetryService } from "@cerebriline/shared";
+import type { ClineCoreStartInput } from "./types";
+export interface EmitSessionStartedTelemetryInput {
+    input: ClineCoreStartInput;
+    sessionId: string;
+    telemetry?: ITelemetryService;
+    clientName?: string;
+    runtimeAddress?: string;
+}
+export declare function emitSessionStartedTelemetry(input: EmitSessionStartedTelemetryInput): void;