archondev 0.1.0 → 1.2.0

package/dist/chunk-SMR7JQK6.js

@@ -0,0 +1,399 @@
+// src/core/keys/manager.ts
+import { homedir as homedir2 } from "os";
+import { join } from "path";
+import { readFile, writeFile, mkdir, chmod } from "fs/promises";
+import { existsSync } from "fs";
+
+// src/core/keys/encryption.ts
+import { createCipheriv, createDecipheriv, randomBytes, scryptSync } from "crypto";
+import { homedir, hostname, userInfo } from "os";
+var ALGORITHM = "aes-256-gcm";
+var IV_LENGTH = 16;
+var AUTH_TAG_LENGTH = 16;
+var SALT_LENGTH = 32;
+var KEY_LENGTH = 32;
+function getDerivedKey(salt) {
+  const machineId = `${hostname()}-${userInfo().username}-${homedir()}`;
+  return scryptSync(machineId, salt, KEY_LENGTH);
+}
+function encrypt(plaintext) {
+  const salt = randomBytes(SALT_LENGTH);
+  const key = getDerivedKey(salt);
+  const iv = randomBytes(IV_LENGTH);
+  const cipher = createCipheriv(ALGORITHM, key, iv);
+  let encrypted = cipher.update(plaintext, "utf8", "hex");
+  encrypted += cipher.final("hex");
+  const authTag = cipher.getAuthTag();
+  const combined = Buffer.concat([
+    salt,
+    iv,
+    authTag,
+    Buffer.from(encrypted, "hex")
+  ]);
+  return combined.toString("base64");
+}
+function decrypt(encryptedData) {
+  const combined = Buffer.from(encryptedData, "base64");
+  const salt = combined.subarray(0, SALT_LENGTH);
+  const iv = combined.subarray(SALT_LENGTH, SALT_LENGTH + IV_LENGTH);
+  const authTag = combined.subarray(
+    SALT_LENGTH + IV_LENGTH,
+    SALT_LENGTH + IV_LENGTH + AUTH_TAG_LENGTH
+  );
+  const encrypted = combined.subarray(SALT_LENGTH + IV_LENGTH + AUTH_TAG_LENGTH);
+  const key = getDerivedKey(salt);
+  const decipher = createDecipheriv(ALGORITHM, key, iv);
+  decipher.setAuthTag(authTag);
+  let decrypted = decipher.update(encrypted.toString("hex"), "hex", "utf8");
+  decrypted += decipher.final("utf8");
+  return decrypted;
+}
+
+// src/core/keys/manager.ts
+var CONFIG_DIR = join(homedir2(), ".archon");
+var KEYS_FILE = join(CONFIG_DIR, "keys.json");
+var CURRENT_VERSION = 2;
+var KeyManager = class {
+  async ensureConfigDir() {
+    if (!existsSync(CONFIG_DIR)) {
+      await mkdir(CONFIG_DIR, { recursive: true, mode: 448 });
+    }
+  }
+  async loadKeys() {
+    try {
+      if (!existsSync(KEYS_FILE)) {
+        return { keys: [], version: CURRENT_VERSION };
+      }
+      const content = await readFile(KEYS_FILE, "utf-8");
+      const data = JSON.parse(content);
+      if (data.version === 1 && !Array.isArray(data.keys)) {
+        const oldKeys = data.keys;
+        const newKeys = Object.values(oldKeys).map((k) => ({
+          ...k,
+          label: k.label ?? "default",
+          isPrimary: k.isPrimary ?? true
+        }));
+        const migrated = { keys: newKeys, version: CURRENT_VERSION };
+        await this.saveKeys(migrated);
+        return migrated;
+      }
+      return data;
+    } catch {
+      return { keys: [], version: CURRENT_VERSION };
+    }
+  }
+  async saveKeys(stored) {
+    await this.ensureConfigDir();
+    const content = JSON.stringify(stored, null, 2);
+    await writeFile(KEYS_FILE, content, { mode: 384 });
+    await chmod(KEYS_FILE, 384);
+  }
+  async addKey(provider, apiKey, label = "default") {
+    try {
+      const stored = await this.loadKeys();
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const existingIndex = stored.keys.findIndex((k) => k.provider === provider && k.label === label);
+      const providerKeys = stored.keys.filter((k) => k.provider === provider);
+      const isPrimary = providerKeys.length === 0 || existingIndex >= 0 && stored.keys[existingIndex]?.isPrimary === true;
+      const newKey = {
+        provider,
+        encryptedKey: encrypt(apiKey),
+        label,
+        isPrimary,
+        createdAt: now,
+        updatedAt: now
+      };
+      if (existingIndex >= 0) {
+        const existing = stored.keys[existingIndex];
+        if (existing) {
+          newKey.createdAt = existing.createdAt;
+          newKey.isPrimary = existing.isPrimary;
+        }
+        stored.keys[existingIndex] = newKey;
+      } else {
+        stored.keys.push(newKey);
+      }
+      await this.saveKeys(stored);
+      return { success: true };
+    } catch (error) {
+      return {
+        success: false,
+        error: `Failed to save key: ${error instanceof Error ? error.message : "Unknown error"}`
+      };
+    }
+  }
+  async getKey(provider, label) {
+    try {
+      const stored = await this.loadKeys();
+      let keyConfig;
+      if (label) {
+        keyConfig = stored.keys.find((k) => k.provider === provider && k.label === label);
+      } else {
+        keyConfig = stored.keys.find((k) => k.provider === provider && k.isPrimary);
+        if (!keyConfig) {
+          keyConfig = stored.keys.find((k) => k.provider === provider);
+        }
+      }
+      if (!keyConfig) {
+        return null;
+      }
+      return decrypt(keyConfig.encryptedKey);
+    } catch {
+      return null;
+    }
+  }
+  async removeKey(provider, label) {
+    try {
+      const stored = await this.loadKeys();
+      let index;
+      if (label) {
+        index = stored.keys.findIndex((k) => k.provider === provider && k.label === label);
+      } else {
+        index = stored.keys.findIndex((k) => k.provider === provider && k.isPrimary);
+        if (index < 0) {
+          index = stored.keys.findIndex((k) => k.provider === provider);
+        }
+      }
+      if (index < 0) {
+        const labelMsg = label ? ` with label "${label}"` : "";
+        return {
+          success: false,
+          error: `No API key found for provider: ${provider}${labelMsg}`
+        };
+      }
+      const removedKey = stored.keys[index];
+      stored.keys.splice(index, 1);
+      if (removedKey?.isPrimary) {
+        const nextKey = stored.keys.find((k) => k.provider === provider);
+        if (nextKey) {
+          nextKey.isPrimary = true;
+        }
+      }
+      await this.saveKeys(stored);
+      return { success: true };
+    } catch (error) {
+      return {
+        success: false,
+        error: `Failed to remove key: ${error instanceof Error ? error.message : "Unknown error"}`
+      };
+    }
+  }
+  async setPrimary(provider, label) {
+    try {
+      const stored = await this.loadKeys();
+      const targetKey = stored.keys.find((k) => k.provider === provider && k.label === label);
+      if (!targetKey) {
+        return {
+          success: false,
+          error: `No key found for ${provider} with label "${label}"`
+        };
+      }
+      for (const key of stored.keys) {
+        if (key.provider === provider) {
+          key.isPrimary = key.label === label;
+        }
+      }
+      await this.saveKeys(stored);
+      return { success: true };
+    } catch (error) {
+      return {
+        success: false,
+        error: `Failed to set primary: ${error instanceof Error ? error.message : "Unknown error"}`
+      };
+    }
+  }
+  async listProviders() {
+    try {
+      const stored = await this.loadKeys();
+      const providers = /* @__PURE__ */ new Set();
+      for (const key of stored.keys) {
+        providers.add(key.provider);
+      }
+      return Array.from(providers);
+    } catch {
+      return [];
+    }
+  }
+  async listKeys(provider) {
+    try {
+      const stored = await this.loadKeys();
+      if (provider) {
+        return stored.keys.filter((k) => k.provider === provider);
+      }
+      return stored.keys;
+    } catch {
+      return [];
+    }
+  }
+  async hasAnyKey() {
+    const stored = await this.loadKeys();
+    return stored.keys.length > 0;
+  }
+  async getKeyConfig(provider, label) {
+    try {
+      const stored = await this.loadKeys();
+      if (label) {
+        return stored.keys.find((k) => k.provider === provider && k.label === label) ?? null;
+      }
+      return stored.keys.find((k) => k.provider === provider && k.isPrimary) ?? stored.keys.find((k) => k.provider === provider) ?? null;
+    } catch {
+      return null;
+    }
+  }
+  async getAdversarialStatus() {
+    const providers = await this.listProviders();
+    const enabled = providers.length >= 2;
+    if (enabled) {
+      return {
+        enabled: true,
+        providerCount: providers.length,
+        providers,
+        message: `Adversarial features enabled (${providers.length} providers: ${providers.join(", ")})`
+      };
+    } else if (providers.length === 1) {
+      return {
+        enabled: false,
+        providerCount: 1,
+        providers,
+        message: `Adversarial features require keys from 2+ providers. Add another provider to unlock.`
+      };
+    } else {
+      return {
+        enabled: false,
+        providerCount: 0,
+        providers: [],
+        message: `No API keys configured. Add keys from 2+ providers to enable adversarial features.`
+      };
+    }
+  }
+};
+var keyManager = new KeyManager();
+
+// src/core/keys/validator.ts
+var KeyValidator = class {
+  async validateKey(provider, apiKey) {
+    switch (provider) {
+      case "anthropic":
+        return this.validateAnthropicKey(apiKey);
+      case "openai":
+        return this.validateOpenAIKey(apiKey);
+      case "google":
+        return this.validateGoogleKey(apiKey);
+      default:
+        return { valid: false, error: `Unknown provider: ${provider}`, provider };
+    }
+  }
+  async validateAnthropicKey(apiKey) {
+    try {
+      const response = await fetch("https://api.anthropic.com/v1/messages", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-api-key": apiKey,
+          "anthropic-version": "2023-06-01"
+        },
+        body: JSON.stringify({
+          model: "claude-3-haiku-20240307",
+          max_tokens: 1,
+          messages: [{ role: "user", content: "Hi" }]
+        })
+      });
+      if (response.status === 401) {
+        return {
+          valid: false,
+          error: "Invalid API key. Please check your Anthropic API key.",
+          provider: "anthropic"
+        };
+      }
+      if (response.status === 400) {
+        const data = await response.json();
+        if (data.error?.message?.includes("credit")) {
+          return {
+            valid: false,
+            error: "API key valid but no credits. Please add credits to your Anthropic account.",
+            provider: "anthropic"
+          };
+        }
+      }
+      if (response.ok || response.status === 429 || response.status === 404) {
+        return { valid: true, provider: "anthropic" };
+      }
+      return {
+        valid: true,
+        provider: "anthropic"
+      };
+    } catch (error) {
+      return {
+        valid: false,
+        error: `Connection error: ${error instanceof Error ? error.message : "Unknown error"}`,
+        provider: "anthropic"
+      };
+    }
+  }
+  async validateOpenAIKey(apiKey) {
+    try {
+      const response = await fetch("https://api.openai.com/v1/models", {
+        method: "GET",
+        headers: {
+          Authorization: `Bearer ${apiKey}`
+        }
+      });
+      if (response.status === 401) {
+        return {
+          valid: false,
+          error: "Invalid API key. Please check your OpenAI API key.",
+          provider: "openai"
+        };
+      }
+      if (response.ok) {
+        return { valid: true, provider: "openai" };
+      }
+      return {
+        valid: false,
+        error: `Validation failed with status ${response.status}`,
+        provider: "openai"
+      };
+    } catch (error) {
+      return {
+        valid: false,
+        error: `Connection error: ${error instanceof Error ? error.message : "Unknown error"}`,
+        provider: "openai"
+      };
+    }
+  }
+  async validateGoogleKey(apiKey) {
+    try {
+      const response = await fetch(
+        `https://generativelanguage.googleapis.com/v1/models?key=${apiKey}`,
+        { method: "GET" }
+      );
+      if (response.status === 400 || response.status === 401 || response.status === 403) {
+        return {
+          valid: false,
+          error: "Invalid API key. Please check your Google AI API key.",
+          provider: "google"
+        };
+      }
+      if (response.ok) {
+        return { valid: true, provider: "google" };
+      }
+      return {
+        valid: false,
+        error: `Validation failed with status ${response.status}`,
+        provider: "google"
+      };
+    } catch (error) {
+      return {
+        valid: false,
+        error: `Connection error: ${error instanceof Error ? error.message : "Unknown error"}`,
+        provider: "google"
+      };
+    }
+  }
+};
+
+export {
+  KeyManager,
+  keyManager,
+  KeyValidator
+};