Security Architecture

~/.craft-agent/credentials.enc

// From secure-storage.ts
const ALGORITHM = 'aes-256-gcm';
const KEY_SIZE = 32;        // 256 bits
const IV_SIZE = 12;         // 96 bits (recommended for GCM)
const AUTH_TAG_SIZE = 16;   // 128 bits
const SALT_SIZE = 32;       // 256 bits
const PBKDF2_ITERATIONS = 100000;

// From secure-storage.ts
function getStableMachineId(): string {
  if (process.platform === 'darwin') {
    // macOS: IOPlatformUUID (tied to logic board)
    return execSync('ioreg -rd1 -c IOPlatformExpertDevice | grep IOPlatformUUID');
  } else if (process.platform === 'win32') {
    // Windows: MachineGuid from registry
    return execSync('reg query HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Cryptography /v MachineGuid');
  } else {
    // Linux: dbus machine-id
    return readFileSync('/var/lib/dbus/machine-id', 'utf-8').trim();
  }
  
  // Fallback: username + homedir
  return `${userInfo().username}:${homedir()}`;
}

function deriveKey(salt: Buffer): Buffer {
  const machineId = getStableMachineId();
  return pbkdf2Sync(
    machineId,
    salt,
    PBKDF2_ITERATIONS,
    KEY_SIZE,
    'sha256'
  );
}

// Simplified encryption flow
function encryptCredentials(data: CredentialStore): Buffer {
  // 1. Generate random salt and IV
  const salt = randomBytes(SALT_SIZE);
  const iv = randomBytes(IV_SIZE);
  
  // 2. Derive encryption key from machine ID
  const key = deriveKey(salt);
  
  // 3. Serialize data to JSON
  const plaintext = JSON.stringify(data);
  
  // 4. Encrypt with AES-256-GCM
  const cipher = createCipheriv('aes-256-gcm', key, iv);
  const ciphertext = Buffer.concat([
    cipher.update(plaintext, 'utf-8'),
    cipher.final()
  ]);
  const authTag = cipher.getAuthTag();
  
  // 5. Assemble file: Header + IV + AuthTag + Ciphertext
  return Buffer.concat([
    MAGIC_BYTES,
    Buffer.alloc(4),  // flags
    salt,
    Buffer.alloc(20), // reserved
    iv,
    authTag,
    ciphertext
  ]);
}

function decryptCredentials(buffer: Buffer): CredentialStore {
  // 1. Validate magic bytes
  if (!buffer.subarray(0, 8).equals(MAGIC_BYTES)) {
    throw new Error('Invalid credentials file format');
  }
  
  // 2. Extract header components
  const salt = buffer.subarray(12, 44);
  const iv = buffer.subarray(64, 76);
  const authTag = buffer.subarray(76, 92);
  const ciphertext = buffer.subarray(92);
  
  // 3. Derive key from machine ID
  const key = deriveKey(salt);
  
  // 4. Decrypt and verify
  const decipher = createDecipheriv('aes-256-gcm', key, iv);
  decipher.setAuthTag(authTag);
  
  const plaintext = Buffer.concat([
    decipher.update(ciphertext),
    decipher.final()  // Throws if auth tag invalid
  ]);
  
  // 5. Parse JSON
  return JSON.parse(plaintext.toString('utf-8'));
}

// From oauth.ts
async function refreshAccessToken(
  tokenEndpoint: string,
  clientId: string,
  refreshToken: string
): Promise<OAuthTokens> {
  const response = await fetch(tokenEndpoint, {
    method: 'POST',
    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
    body: new URLSearchParams({
      grant_type: 'refresh_token',
      refresh_token: refreshToken,
      client_id: clientId
    })
  });
  
  if (!response.ok) {
    throw new Error('Token refresh failed');
  }
  
  const data = await response.json();
  return {
    accessToken: data.access_token,
    refreshToken: data.refresh_token || refreshToken,
    expiresAt: Date.now() + data.expires_in * 1000,
    tokenType: data.token_type
  };
}

┌─────────────────────────────────────────┐
│ Main Process (Electron)                  │
│                                          │
│  ┌──────────────────┐                   │
│  │ McpClientPool    │                   │
│  │ - Manages all    │                   │
│  │   source conns   │                   │
│  └──────┬───────────┘                   │
│         │                                │
└─────────┼────────────────────────────────┘
          │
          │ spawns subprocesses
          │
          ├────────────────────┐
          │                    │
          ▼                    ▼
┌─────────────────┐  ┌─────────────────┐
│ MCP Server 1    │  │ MCP Server 2    │
│ (Linear)        │  │ (GitHub)        │
│                 │  │                 │
│ - Own memory    │  │ - Own memory    │
│ - Own env vars  │  │ - Own env vars  │
│ - No cross-talk │  │ - No cross-talk │
└─────────────────┘  └─────────────────┘

// Bridge reads credentials from cache file
const credentialPath = join(
  getSourcePath(workspaceRootPath, sourceSlug),
  '.credential-cache.json'
);

function readCredential(): StoredCredential | null {
  if (!existsSync(credentialPath)) return null;
  
  const data = readFileSync(credentialPath, 'utf-8');
  const cred = JSON.parse(data);
  
  // Check expiry
  if (cred.expiresAt && cred.expiresAt < Date.now()) {
    return null; // Expired
  }
  
  return cred;
}

// Sensitive patterns blocked from agent context
const BLOCKED_ENV_PATTERNS = [
  /^API_KEY$/i,
  /^SECRET$/i,
  /^PASSWORD$/i,
  /^TOKEN$/i,
  /^AWS_/i,
  /^OPENAI_/i,
  /^ANTHROPIC_/i
];

function filterEnvironment(env: Record<string, string>): Record<string, string> {
  const filtered: Record<string, string> = {};
  
  for (const [key, value] of Object.entries(env)) {
    if (BLOCKED_ENV_PATTERNS.some(pattern => pattern.test(key))) {
      continue; // Skip sensitive vars
    }
    filtered[key] = value;
  }
  
  return filtered;
}

import { getCredentialManager } from '@craft-agent/shared/credentials';

const manager = getCredentialManager();

// Get credential (auto-decrypts)
const cred = await manager.get({
  type: 'llm',
  provider: 'claude',
  account: 'default'
});

// Set credential (auto-encrypts)
await manager.set(
  { type: 'source', provider: 'linear', account: 'oauth' },
  {
    type: 'oauth',
    accessToken: 'lin_...',
    refreshToken: 'rt_...',
    expiresAt: Date.now() + 3600000
  }
);

// Delete credential
await manager.delete({
  type: 'source',
  provider: 'linear',
  account: 'oauth'
});

type CredentialId = {
  type: 'llm' | 'source' | 'mcp';
  provider: string;
  account: string;
};

type StoredCredential = 
  | { type: 'api_key'; apiKey: string; }
  | { type: 'oauth'; accessToken: string; refreshToken?: string; expiresAt?: number; tokenType: string; }
  | { type: 'basic'; username: string; password: string; }
  | { type: 'bearer'; token: string; };