cline-sdk
Version:
Comprehensive SDK for Cline - AI-powered development assistant with database integration, execution modes, and custom functions
215 lines • 8.69 kB
JavaScript
;
/**
* Cline SDK Configuration System
* Handles API keys, settings, and tool configurations
*/
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = { enumerable: true, get: function() { return m[k]; } };
}
Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
});
var __importStar = (this && this.__importStar) || (function () {
var ownKeys = function(o) {
ownKeys = Object.getOwnPropertyNames || function (o) {
var ar = [];
for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
return ar;
};
return ownKeys(o);
};
return function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
__setModuleDefault(result, mod);
return result;
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
exports.ClineConfigManager = void 0;
const fs = __importStar(require("fs"));
const path = __importStar(require("path"));
const os = __importStar(require("os"));
class ClineConfigManager {
constructor(configDir) {
const defaultConfigDir = configDir || path.join(os.homedir(), ".cline-sdk");
this.configPath = path.join(defaultConfigDir, "config.json");
// Ensure config directory exists
if (!fs.existsSync(defaultConfigDir)) {
fs.mkdirSync(defaultConfigDir, { recursive: true });
}
// Load or create default config
this.config = this.loadConfig();
}
loadConfig() {
try {
if (fs.existsSync(this.configPath)) {
const configData = fs.readFileSync(this.configPath, "utf8");
const loadedConfig = JSON.parse(configData);
return { ...this.getDefaultConfig(), ...loadedConfig };
}
}
catch (error) {
console.warn("Failed to load config, using defaults:", error);
}
return this.getDefaultConfig();
}
getDefaultConfig() {
return {
apiProvider: "anthropic",
apiKey: process.env.ANTHROPIC_API_KEY || process.env.CLINE_API_KEY,
model: "claude-3-sonnet-20240229",
enabledTools: ["Write", "Read", "Bash"],
enableCustomFunctions: true,
enableDatabase: false,
maxRequestsPerTask: 50,
timeout: 30000,
storageType: "local",
workingDirectory: process.cwd(),
alwaysAllowReadOnly: false,
supabase: process.env.SUPABASE_URL && process.env.SUPABASE_ANON_KEY
? {
url: process.env.SUPABASE_URL,
anonKey: process.env.SUPABASE_ANON_KEY,
serviceKey: process.env.SUPABASE_SERVICE_KEY, // Optional admin key
bucketName: process.env.SUPABASE_BUCKET || "cline-files",
projectPath: process.env.SUPABASE_PROJECT_PATH,
}
: undefined,
database: process.env.DATABASE_URL ||
(process.env.DB_HOST && process.env.DB_NAME && process.env.DB_USER && process.env.DB_PASSWORD)
? {
host: process.env.DB_HOST || "localhost",
port: parseInt(process.env.DB_PORT || "5432", 10),
database: process.env.DB_NAME || process.env.DB_DATABASE || "postgres",
username: process.env.DB_USER || process.env.DB_USERNAME || "postgres",
password: process.env.DB_PASSWORD || "",
ssl: process.env.DB_SSL === "true" || process.env.DATABASE_SSL === "true",
maxConnections: parseInt(process.env.DB_MAX_CONNECTIONS || "20", 10),
idleTimeoutMillis: parseInt(process.env.DB_IDLE_TIMEOUT || "30000", 10),
connectionTimeoutMillis: parseInt(process.env.DB_CONNECTION_TIMEOUT || "10000", 10),
permissions: {
allowRead: process.env.DB_ALLOW_READ !== "false",
allowWrite: process.env.DB_ALLOW_WRITE === "true",
allowDelete: process.env.DB_ALLOW_DELETE === "true",
allowSchemaChanges: process.env.DB_ALLOW_SCHEMA_CHANGES === "true",
allowRLSManagement: process.env.DB_ALLOW_RLS === "true",
restrictedTables: process.env.DB_RESTRICTED_TABLES
? process.env.DB_RESTRICTED_TABLES.split(",")
: [],
allowedTables: process.env.DB_ALLOWED_TABLES ? process.env.DB_ALLOWED_TABLES.split(",") : [],
},
}
: undefined,
temperature: 0.7,
maxTokens: 4000,
useCache: true,
retry: {
enabled: true,
maxAttempts: 3,
waitTimeMs: 6000, // 6 seconds as requested
exponentialBackoff: false,
retryOnErrors: ["llm_error", "api_error", "timeout_error"]
},
};
}
getConfig() {
return { ...this.config };
}
updateConfig(updates) {
this.config = { ...this.config, ...updates };
this.saveConfig();
}
setApiKey(apiKey) {
this.config.apiKey = apiKey;
this.saveConfig();
}
setWorkingDirectory(directory) {
if (fs.existsSync(directory)) {
this.config.workingDirectory = path.resolve(directory);
this.saveConfig();
}
else {
throw new Error(`Directory does not exist: ${directory}`);
}
}
enableTool(toolName) {
if (!this.config.enabledTools.includes(toolName)) {
this.config.enabledTools.push(toolName);
this.saveConfig();
}
}
disableTool(toolName) {
this.config.enabledTools = this.config.enabledTools.filter((tool) => tool !== toolName);
this.saveConfig();
}
saveConfig() {
try {
fs.writeFileSync(this.configPath, JSON.stringify(this.config, null, 2), "utf8");
}
catch (error) {
console.error("Failed to save config:", error);
}
}
getConfigPath() {
return this.configPath;
}
// Validation methods
validateConfig() {
const errors = [];
if (!this.config.apiKey) {
errors.push("API key is required");
}
if (!fs.existsSync(this.config.workingDirectory)) {
errors.push(`Working directory does not exist: ${this.config.workingDirectory}`);
}
if (this.config.maxRequestsPerTask < 1) {
errors.push("maxRequestsPerTask must be at least 1");
}
if (this.config.timeout < 1000) {
errors.push("timeout must be at least 1000ms");
}
return {
valid: errors.length === 0,
errors,
};
}
// Environment-based configuration
static fromEnvironment() {
const config = new ClineConfigManager();
// Override with environment variables
const envConfig = {};
if (process.env.ANTHROPIC_API_KEY) {
envConfig.apiKey = process.env.ANTHROPIC_API_KEY;
envConfig.apiProvider = "anthropic";
}
if (process.env.OPENAI_API_KEY) {
envConfig.apiKey = process.env.OPENAI_API_KEY;
envConfig.apiProvider = "openai";
}
if (process.env.CLINE_WORKING_DIR) {
envConfig.workingDirectory = process.env.CLINE_WORKING_DIR;
}
if (process.env.CLINE_MODEL) {
envConfig.model = process.env.CLINE_MODEL;
}
if (process.env.CLINE_MAX_REQUESTS) {
envConfig.maxRequestsPerTask = parseInt(process.env.CLINE_MAX_REQUESTS, 10);
}
config.updateConfig(envConfig);
return config;
}
}
exports.ClineConfigManager = ClineConfigManager;
//# sourceMappingURL=cline-config.js.map