erosolar-cli 1.5.2 → 1.5.4

package/dist/bin/core/preferences.js

@@ -0,0 +1,224 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+const CONFIG_DIR = join(homedir(), '.erosolar');
+const SETTINGS_PATH = join(CONFIG_DIR, 'settings.json');
+const CURRENT_VERSION = 2;
+export function loadActiveProfilePreference() {
+    const payload = readSettingsFile();
+    if (!payload?.activeProfile) {
+        return null;
+    }
+    return normalizeProfileNameValue(payload.activeProfile);
+}
+export function saveActiveProfilePreference(profile) {
+    const normalized = normalizeProfileNameValue(profile);
+    if (!normalized) {
+        return;
+    }
+    const payload = readSettingsFile() ?? { version: CURRENT_VERSION, profiles: {} };
+    payload.version = CURRENT_VERSION;
+    payload.profiles = payload.profiles ?? {};
+    payload.activeProfile = normalized;
+    writeSettingsFile(payload);
+}
+export function clearActiveProfilePreference() {
+    const payload = readSettingsFile();
+    if (!payload?.activeProfile) {
+        return;
+    }
+    payload.version = CURRENT_VERSION;
+    payload.profiles = payload.profiles ?? {};
+    delete payload.activeProfile;
+    writeSettingsFile(payload);
+}
+export function loadModelPreference(profile) {
+    const payload = readSettingsFile();
+    if (!payload) {
+        return null;
+    }
+    const entry = payload.profiles?.[profile];
+    if (!entry || typeof entry !== 'object') {
+        return null;
+    }
+    if (typeof entry.provider !== 'string' || typeof entry.model !== 'string') {
+        return null;
+    }
+    return { ...entry };
+}
+export function saveModelPreference(profile, preference) {
+    const payload = readSettingsFile() ?? { version: CURRENT_VERSION, profiles: {} };
+    payload.version = CURRENT_VERSION;
+    payload.profiles = payload.profiles ?? {};
+    payload.profiles[profile] = { ...preference };
+    writeSettingsFile(payload);
+}
+export function loadToolSettings() {
+    const payload = readSettingsFile();
+    if (!payload?.tools) {
+        return null;
+    }
+    const enabledTools = normalizeToolIds(payload.tools.enabledTools);
+    return { enabledTools };
+}
+export function saveToolSettings(settings) {
+    const payload = readSettingsFile() ?? { version: CURRENT_VERSION, profiles: {} };
+    payload.version = CURRENT_VERSION;
+    payload.profiles = payload.profiles ?? {};
+    payload.tools = {
+        enabledTools: normalizeToolIds(settings.enabledTools),
+    };
+    writeSettingsFile(payload);
+}
+export function clearToolSettings() {
+    const payload = readSettingsFile();
+    if (!payload) {
+        return;
+    }
+    payload.version = CURRENT_VERSION;
+    payload.profiles = payload.profiles ?? {};
+    if (payload.tools) {
+        delete payload.tools;
+    }
+    writeSettingsFile(payload);
+}
+export function loadSessionPreferences() {
+    const payload = readSettingsFile();
+    const section = payload?.session;
+    return {
+        autosave: typeof section?.autosave === 'boolean' ? section.autosave : true,
+        autoResume: typeof section?.autoResume === 'boolean' ? section.autoResume : true,
+        lastSessionId: typeof section?.lastSessionId === 'string' && section.lastSessionId.trim()
+            ? section.lastSessionId.trim()
+            : null,
+        thinkingMode: parseThinkingMode(section?.thinkingMode),
+    };
+}
+export function saveSessionPreferences(preferences) {
+    const payload = readSettingsFile() ?? { version: CURRENT_VERSION, profiles: {} };
+    payload.version = CURRENT_VERSION;
+    payload.profiles = payload.profiles ?? {};
+    const section = payload.session ?? {};
+    if (typeof preferences.autosave === 'boolean') {
+        section.autosave = preferences.autosave;
+    }
+    if (typeof preferences.autoResume === 'boolean') {
+        section.autoResume = preferences.autoResume;
+    }
+    if ('lastSessionId' in preferences) {
+        section.lastSessionId = preferences.lastSessionId ?? undefined;
+    }
+    if (preferences.thinkingMode) {
+        section.thinkingMode = preferences.thinkingMode;
+    }
+    payload.session = section;
+    writeSettingsFile(payload);
+}
+function readSettingsFile() {
+    try {
+        if (!existsSync(SETTINGS_PATH)) {
+            return null;
+        }
+        const raw = readFileSync(SETTINGS_PATH, 'utf8');
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== 'object') {
+            return null;
+        }
+        const profiles = typeof parsed.profiles === 'object' && parsed.profiles !== null ? parsed.profiles : {};
+        const payload = {
+            version: typeof parsed.version === 'number' ? parsed.version : CURRENT_VERSION,
+            profiles,
+        };
+        const tools = parseToolSettings(parsed.tools);
+        if (tools) {
+            payload.tools = tools;
+        }
+        const session = parseSessionPreferences(parsed.session);
+        if (session) {
+            payload.session = session;
+        }
+        const rawProfile = typeof parsed.activeProfile === 'string' && parsed.activeProfile.trim()
+            ? parsed.activeProfile.trim()
+            : undefined;
+        if (rawProfile) {
+            payload.activeProfile = rawProfile;
+        }
+        return payload;
+    }
+    catch {
+        return null;
+    }
+}
+function writeSettingsFile(payload) {
+    try {
+        mkdirSync(CONFIG_DIR, { recursive: true });
+        writeFileSync(SETTINGS_PATH, JSON.stringify(payload, null, 2));
+    }
+    catch {
+    }
+}
+function parseToolSettings(value) {
+    if (!value || typeof value !== 'object') {
+        return undefined;
+    }
+    const record = value;
+    if (!Array.isArray(record.enabledTools)) {
+        return { enabledTools: [] };
+    }
+    return { enabledTools: normalizeToolIds(record.enabledTools) };
+}
+function parseSessionPreferences(value) {
+    if (!value || typeof value !== 'object') {
+        return undefined;
+    }
+    const record = value;
+    const section = {};
+    if (typeof record.autosave === 'boolean') {
+        section.autosave = record.autosave;
+    }
+    if (typeof record.autoResume === 'boolean') {
+        section.autoResume = record.autoResume;
+    }
+    if (typeof record.lastSessionId === 'string' && record.lastSessionId.trim()) {
+        section.lastSessionId = record.lastSessionId.trim();
+    }
+    if (record.thinkingMode) {
+        section.thinkingMode = parseThinkingMode(record.thinkingMode);
+    }
+    return section;
+}
+function parseThinkingMode(value) {
+    if (value === 'concise' || value === 'extended' || value === 'balanced') {
+        return value;
+    }
+    return 'balanced';
+}
+function normalizeToolIds(ids) {
+    if (!Array.isArray(ids)) {
+        return [];
+    }
+    const seen = new Set();
+    const result = [];
+    for (const entry of ids) {
+        if (typeof entry !== 'string') {
+            continue;
+        }
+        const id = entry.trim();
+        if (!id || seen.has(id)) {
+            continue;
+        }
+        seen.add(id);
+        result.push(id);
+    }
+    return result;
+}
+function normalizeProfileNameValue(value) {
+    if (typeof value !== 'string') {
+        return null;
+    }
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return null;
+    }
+    return trimmed;
+}

package/dist/bin/core/schemaValidator.js

@@ -0,0 +1,92 @@
+export class ToolArgumentValidationError extends Error {
+    constructor(toolName, issues) {
+        super(formatMessage(toolName, issues));
+        this.name = 'ToolArgumentValidationError';
+    }
+}
+export function validateToolArguments(toolName, schema, args) {
+    if (!schema || schema.type !== 'object') {
+        return;
+    }
+    const errors = [];
+    const properties = schema.properties ?? {};
+    const required = Array.isArray(schema.required) ? schema.required : [];
+    for (const property of required) {
+        if (!hasArgument(args, property)) {
+            errors.push(`Missing required property "${property}".`);
+        }
+    }
+    for (const [key, value] of Object.entries(args)) {
+        const definition = properties[key];
+        if (!definition) {
+            if (schema.additionalProperties === false) {
+                errors.push(`Property "${key}" is not allowed.`);
+            }
+            continue;
+        }
+        validateSchemaProperty(definition, value, key, errors);
+    }
+    if (errors.length) {
+        throw new ToolArgumentValidationError(toolName, errors);
+    }
+}
+function validateSchemaProperty(definition, value, path, errors) {
+    switch (definition.type) {
+        case 'string': {
+            if (typeof value !== 'string') {
+                errors.push(`Argument "${path}" must be a string.`);
+                return;
+            }
+            if (definition.enum && !definition.enum.includes(value)) {
+                errors.push(`Argument "${path}" must be one of: ${definition.enum.map((entry) => `"${entry}"`).join(', ')}.`);
+            }
+            if (typeof definition.minLength === 'number' && value.length < definition.minLength) {
+                errors.push(`Argument "${path}" must be at least ${definition.minLength} character${definition.minLength === 1 ? '' : 's'} long.`);
+            }
+            return;
+        }
+        case 'number': {
+            if (typeof value !== 'number' || Number.isNaN(value)) {
+                errors.push(`Argument "${path}" must be a number.`);
+            }
+            return;
+        }
+        case 'boolean': {
+            if (typeof value !== 'boolean') {
+                errors.push(`Argument "${path}" must be a boolean.`);
+            }
+            return;
+        }
+        case 'array': {
+            if (!Array.isArray(value)) {
+                errors.push(`Argument "${path}" must be an array.`);
+                return;
+            }
+            validateArrayItems(definition, value, path, errors);
+            return;
+        }
+        default:
+            return;
+    }
+}
+function validateArrayItems(definition, value, path, errors) {
+    const itemSchema = definition.items;
+    if (!itemSchema) {
+        return;
+    }
+    for (let index = 0; index < value.length; index += 1) {
+        const entry = value[index];
+        validateSchemaProperty(itemSchema, entry, `${path}[${index}]`, errors);
+    }
+}
+function hasArgument(args, key) {
+    if (!Object.hasOwn(args, key)) {
+        return false;
+    }
+    const value = args[key];
+    return value !== undefined && value !== null;
+}
+function formatMessage(toolName, issues) {
+    const detail = issues.join(' ');
+    return `Invalid arguments for "${toolName}": ${detail}`;
+}

package/dist/bin/core/secretStore.js

@@ -0,0 +1,199 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+const SECRET_DEFINITIONS = [
+    {
+        id: 'OPENAI_API_KEY',
+        label: 'OpenAI API Key',
+        description: 'Required to run OpenAI GPT and Erosolar Code models.',
+        envVar: 'OPENAI_API_KEY',
+        providers: ['openai'],
+    },
+    {
+        id: 'ANTHROPIC_API_KEY',
+        label: 'Anthropic API Key',
+        description: 'Required to run Anthropic Sonnet, Opus, or Haiku models.',
+        envVar: 'ANTHROPIC_API_KEY',
+        providers: ['anthropic'],
+    },
+    {
+        id: 'DEEPSEEK_API_KEY',
+        label: 'DeepSeek API Key',
+        description: 'Required to run DeepSeek Reasoner or Chat models.',
+        envVar: 'DEEPSEEK_API_KEY',
+        providers: ['deepseek'],
+    },
+    {
+        id: 'XAI_API_KEY',
+        label: 'xAI API Key',
+        description: 'Required to run Grok models from xAI.',
+        envVar: 'XAI_API_KEY',
+        providers: ['xai'],
+    },
+    {
+        id: 'GEMINI_API_KEY',
+        label: 'Google Gemini API Key',
+        description: 'Required to run Gemini 2.5 Pro or Flash models.',
+        envVar: 'GEMINI_API_KEY',
+        providers: ['google'],
+    },
+    {
+        id: 'BRAVE_SEARCH_API_KEY',
+        label: 'Brave Search API Key',
+        description: 'Optional: unlock WebSearch using the Brave Search API.',
+        envVar: 'BRAVE_SEARCH_API_KEY',
+        providers: [],
+    },
+    {
+        id: 'SERPAPI_API_KEY',
+        label: 'SerpAPI Key',
+        description: 'Optional: fallback WebSearch provider via SerpAPI.',
+        envVar: 'SERPAPI_API_KEY',
+        providers: [],
+    },
+    {
+        id: 'TAVILY_API_KEY',
+        label: 'Tavily API Key',
+        description: 'Recommended: Primary WebSearch and WebExtract provider. Get yours at https://tavily.com',
+        envVar: 'TAVILY_API_KEY',
+        providers: [],
+    },
+    {
+        id: 'SMTP_USER',
+        label: 'Email Address',
+        description: 'Your email address for sending emails (e.g., you@gmail.com).',
+        envVar: 'SMTP_USER',
+        providers: [],
+    },
+    {
+        id: 'SMTP_PASSWORD',
+        label: 'Email App Password',
+        description: 'App password for your email (NOT your regular password). For Gmail: https://myaccount.google.com/apppasswords',
+        envVar: 'SMTP_PASSWORD',
+        providers: [],
+    },
+    {
+        id: 'SMTP_PROVIDER',
+        label: 'Email Provider',
+        description: 'Email provider: gmail, outlook, yahoo, icloud, zoho (default: gmail).',
+        envVar: 'SMTP_PROVIDER',
+        providers: [],
+    },
+    {
+        id: 'SMTP_FROM_NAME',
+        label: 'Email Display Name',
+        description: 'Optional: Display name shown in sent emails (e.g., "John Doe").',
+        envVar: 'SMTP_FROM_NAME',
+        providers: [],
+    },
+    {
+        id: 'SMTP_HOST',
+        label: 'Custom SMTP Host',
+        description: 'Optional: Custom SMTP server hostname (only for non-standard providers).',
+        envVar: 'SMTP_HOST',
+        providers: [],
+    },
+    {
+        id: 'SMTP_PORT',
+        label: 'Custom SMTP Port',
+        description: 'Optional: Custom SMTP port (only for non-standard providers, default: 587).',
+        envVar: 'SMTP_PORT',
+        providers: [],
+    },
+];
+const envCodexHome = process.env['CODEX_HOME'];
+const SECRET_DIR = envCodexHome ? resolve(envCodexHome) : join(homedir(), '.codex');
+const SECRET_FILE = join(SECRET_DIR, 'secrets.json');
+export class MissingSecretError extends Error {
+    constructor(secret) {
+        super(`${secret.label} is not configured.`);
+        this.secret = secret;
+        this.name = 'MissingSecretError';
+    }
+}
+export function listSecretDefinitions() {
+    return [...SECRET_DEFINITIONS];
+}
+export function getSecretValue(id) {
+    const envValue = sanitize(process.env[id]);
+    if (envValue) {
+        return envValue;
+    }
+    const store = readSecretStore();
+    const storedValue = sanitize(store[id]);
+    if (!storedValue) {
+        return null;
+    }
+    process.env[id] = storedValue;
+    return storedValue;
+}
+export function setSecretValue(id, rawValue) {
+    const value = sanitize(rawValue);
+    if (!value) {
+        throw new Error('Secret value cannot be blank.');
+    }
+    const store = readSecretStore();
+    store[id] = value;
+    writeSecretStore(store);
+    process.env[id] = value;
+}
+export function maskSecret(value) {
+    if (!value) {
+        return '';
+    }
+    if (value.length <= 4) {
+        return '*'.repeat(value.length);
+    }
+    const suffix = value.slice(-4);
+    const prefix = '*'.repeat(Math.max(0, value.length - 4));
+    return `${prefix}${suffix}`;
+}
+export function ensureSecretForProvider(provider) {
+    const definition = findDefinitionForProvider(provider);
+    const value = getSecretValue(definition.id);
+    if (!value) {
+        throw new MissingSecretError(definition);
+    }
+    process.env[definition.envVar] = value;
+    return value;
+}
+export function getSecretDefinitionForProvider(provider) {
+    return SECRET_DEFINITIONS.find((entry) => entry.providers.includes(provider)) ?? null;
+}
+function readSecretStore() {
+    if (!existsSync(SECRET_FILE)) {
+        return {};
+    }
+    try {
+        const content = readFileSync(SECRET_FILE, 'utf8');
+        const parsed = JSON.parse(content);
+        if (parsed && typeof parsed === 'object') {
+            return parsed;
+        }
+    }
+    catch {
+        return {};
+    }
+    return {};
+}
+function writeSecretStore(store) {
+    const directory = dirname(SECRET_FILE);
+    mkdirSync(directory, { recursive: true });
+    const payload = JSON.stringify(store, null, 2);
+    writeFileSync(SECRET_FILE, `${payload}
+`);
+}
+function findDefinitionForProvider(provider) {
+    const definition = getSecretDefinitionForProvider(provider);
+    if (!definition) {
+        throw new Error(`No secret configuration for provider "${provider}".`);
+    }
+    return definition;
+}
+function sanitize(value) {
+    if (typeof value !== 'string') {
+        return null;
+    }
+    const trimmed = value.trim();
+    return trimmed.length ? trimmed : null;
+}

package/dist/bin/core/sessionStore.js

@@ -0,0 +1,187 @@
+import { randomUUID } from 'node:crypto';
+import { mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+const dataRoot = process.env['EROSOLAR_DATA_DIR']?.trim() || join(homedir(), '.erosolar');
+const sessionsDir = join(dataRoot, 'sessions');
+const indexPath = join(sessionsDir, 'index.json');
+export function listSessions(profile) {
+    const index = readIndex();
+    const entries = Object.values(index.entries);
+    const filtered = profile ? entries.filter((entry) => entry.profile === profile) : entries;
+    return filtered.sort((a, b) => {
+        const aTime = Date.parse(a.updatedAt ?? '') || 0;
+        const bTime = Date.parse(b.updatedAt ?? '') || 0;
+        return bTime - aTime;
+    });
+}
+export function saveSessionSnapshot(options) {
+    ensureDirectory();
+    if (!Array.isArray(options.messages)) {
+        throw new Error('Session snapshots must include the entire message history array.');
+    }
+    const index = readIndex();
+    const now = new Date().toISOString();
+    const existingId = options.id ?? null;
+    const summaryId = existingId && index.entries[existingId] ? existingId : randomUUID();
+    const previous = index.entries[summaryId];
+    const summary = {
+        id: summaryId,
+        title: sanitizeTitle(options.title) ?? previous?.title ?? buildDefaultTitle(options.messages),
+        profile: options.profile,
+        provider: options.provider,
+        model: options.model,
+        workspaceRoot: options.workspaceRoot ?? previous?.workspaceRoot ?? undefined,
+        createdAt: previous?.createdAt ?? now,
+        updatedAt: now,
+        messageCount: options.messages.length,
+    };
+    const payload = {
+        ...summary,
+        messages: options.messages,
+    };
+    writeFileSync(getSessionPath(summaryId), JSON.stringify(payload, null, 2), 'utf8');
+    index.entries[summaryId] = summary;
+    writeIndex(index);
+    return summary;
+}
+export function loadSessionById(id) {
+    if (!id) {
+        return null;
+    }
+    try {
+        const raw = readFileSync(getSessionPath(id), 'utf8');
+        const parsed = JSON.parse(raw);
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+export function deleteSession(id) {
+    if (!id) {
+        return false;
+    }
+    const index = readIndex();
+    if (!index.entries[id]) {
+        return false;
+    }
+    try {
+        rmSync(getSessionPath(id), { force: true });
+    }
+    catch {
+        // ignore
+    }
+    delete index.entries[id];
+    writeIndex(index);
+    return true;
+}
+export function saveAutosaveSnapshot(profile, options) {
+    ensureDirectory();
+    const payload = {
+        id: `autosave-${profile}`,
+        profile,
+        provider: options.provider,
+        model: options.model,
+        workspaceRoot: options.workspaceRoot ?? undefined,
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        title: sanitizeTitle(options.title) ?? buildDefaultTitle(options.messages),
+        messageCount: options.messages.length,
+        messages: options.messages,
+    };
+    writeFileSync(getAutosavePath(profile), JSON.stringify(payload, null, 2), 'utf8');
+}
+export function loadAutosaveSnapshot(profile) {
+    try {
+        const raw = readFileSync(getAutosavePath(profile), 'utf8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+export function clearAutosaveSnapshot(profile) {
+    try {
+        rmSync(getAutosavePath(profile), { force: true });
+    }
+    catch {
+        // ignore
+    }
+}
+function readIndex() {
+    ensureDirectory();
+    try {
+        const raw = readFileSync(indexPath, 'utf8');
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== 'object' || typeof parsed.entries !== 'object') {
+            return { entries: {} };
+        }
+        return { entries: { ...parsed.entries } };
+    }
+    catch {
+        return { entries: {} };
+    }
+}
+function writeIndex(index) {
+    ensureDirectory();
+    writeFileSync(indexPath, JSON.stringify(index, null, 2), 'utf8');
+}
+function ensureDirectory() {
+    mkdirSync(sessionsDir, { recursive: true });
+}
+function getSessionPath(id) {
+    return join(sessionsDir, `${id}.json`);
+}
+function getAutosavePath(profile) {
+    return join(sessionsDir, `${profile}-autosave.json`);
+}
+function sanitizeTitle(value) {
+    if (typeof value !== 'string') {
+        return null;
+    }
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return null;
+    }
+    return trimmed.slice(0, 160);
+}
+function buildDefaultTitle(messages) {
+    for (const message of messages) {
+        if (message.role !== 'user') {
+            continue;
+        }
+        const condensed = message.content.trim().replace(/\s+/g, ' ');
+        if (condensed) {
+            return condensed.slice(0, 160);
+        }
+    }
+    return `Session ${new Date().toLocaleString()}`;
+}
+function pruneOrphans() {
+    try {
+        ensureDirectory();
+        const index = readIndex();
+        const known = new Set(Object.keys(index.entries));
+        for (const file of readdirSync(sessionsDir)) {
+            if (!file.endsWith('.json')) {
+                continue;
+            }
+            if (file === 'index.json' || file.includes('-autosave')) {
+                continue;
+            }
+            const id = file.slice(0, -5);
+            if (!known.has(id)) {
+                const candidate = join(sessionsDir, file);
+                const stats = statSync(candidate);
+                if (stats.isFile()) {
+                    rmSync(candidate, { force: true });
+                }
+            }
+        }
+    }
+    catch {
+        // best-effort cleanup
+    }
+}
+pruneOrphans();