contextwise 0.1.0 → 0.2.0

package/dist/chunk-OYCA37PJ.js

@@ -0,0 +1,710 @@
+import {
+  cloudClient,
+  logger
+} from "./chunk-WP7RH2Z2.js";
+
+// src/cloud/sync_manager.ts
+import { existsSync as existsSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
+import { homedir as homedir5 } from "os";
+import { join as join5 } from "path";
+
+// src/config/loader.ts
+import { existsSync, readFileSync } from "fs";
+import { homedir } from "os";
+import { isAbsolute, join, resolve } from "path";
+
+// src/config/schema.ts
+import { z } from "zod";
+var StdioUpstreamConfigSchema = z.object({
+  command: z.string(),
+  args: z.array(z.string()).default([]),
+  env: z.record(z.string()).default({}),
+  cwd: z.string().optional(),
+  autoRestart: z.boolean().default(true)
+});
+var HttpUpstreamConfigSchema = z.object({
+  url: z.string().url(),
+  headers: z.record(z.string()).default({}),
+  transport: z.enum(["streamable-http", "sse", "auto"]).default("auto"),
+  autoReconnect: z.boolean().default(true)
+});
+var UpstreamServerConfigSchema = z.union([
+  StdioUpstreamConfigSchema,
+  HttpUpstreamConfigSchema
+]);
+function warnIfInsecureHttp(urlStr, headers) {
+  try {
+    const parsed = new URL(urlStr);
+    if (parsed.protocol === "http:") {
+      const isLocalhost = ["localhost", "127.0.0.1", "::1", "[::1]"].includes(parsed.hostname);
+      if (!isLocalhost && headers) {
+        const hasAuthHeader = Object.keys(headers).some(
+          (h) => ["authorization", "cookie", "x-api-key", "api-key", "token"].includes(h.toLowerCase())
+        );
+        if (hasAuthHeader) {
+          console.warn(
+            `[SECURITY WARNING] Upstream URL "${urlStr}" is using unencrypted HTTP with sensitive authentication headers to non-localhost destination "${parsed.hostname}".`
+          );
+        }
+      }
+    }
+  } catch {
+  }
+}
+function isStdioUpstream(config) {
+  return "command" in config;
+}
+function isHttpUpstream(config) {
+  return "url" in config;
+}
+var ProxyConfigSchema = z.object({
+  transport: z.enum(["stdio", "sse", "http"]).default("stdio"),
+  port: z.number().int().min(1024).max(65535).default(3456),
+  logLevel: z.enum(["debug", "info", "warn", "error", "silent"]).default("info")
+});
+var RoutingConfigSchema = z.object({
+  strategy: z.enum(["hybrid", "bm25", "vector", "passthrough"]).default("hybrid"),
+  topK: z.number().int().min(1).max(50).default(5),
+  similarityThreshold: z.number().min(0).max(1).default(0.45),
+  pinnedTools: z.array(z.string()).default([]),
+  maxActiveTools: z.number().int().min(1).max(100).default(10),
+  enableBrowseServers: z.boolean().default(false),
+  enableAddServer: z.boolean().default(false),
+  enableCloudSync: z.boolean().default(true),
+  allowCustomCommands: z.boolean().default(false),
+  persistAddedServers: z.boolean().default(false)
+});
+var GuardrailsConfigSchema = z.object({
+  enableCache: z.boolean().default(true),
+  cacheTtlSeconds: z.number().int().min(1).default(120),
+  maxCallsPerMinute: z.number().int().min(1).default(60),
+  loopBreakerThreshold: z.number().int().min(1).default(3),
+  callTimeoutMs: z.number().int().min(1e3).default(3e4)
+});
+var ContextWiseConfigSchema = z.object({
+  $schema: z.string().optional(),
+  version: z.string().default("1.0.0"),
+  proxy: ProxyConfigSchema.default({}),
+  routing: RoutingConfigSchema.default({}),
+  guardrails: GuardrailsConfigSchema.default({}),
+  upstreams: z.record(UpstreamServerConfigSchema).default({})
+});
+
+// src/config/loader.ts
+var ConfigLoader = class {
+  /**
+   * Discovers and loads configuration from contextwise.json or imported client configs.
+   */
+  static load(options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    if (process.env.CONTEXTWISE_CONFIG && !options.configPath) {
+      const envPath = isAbsolute(process.env.CONTEXTWISE_CONFIG) ? process.env.CONTEXTWISE_CONFIG : resolve(cwd, process.env.CONTEXTWISE_CONFIG);
+      if (existsSync(envPath)) {
+        return this.parseConfigFile(envPath);
+      }
+    }
+    if (options.configPath) {
+      const explicitPath = isAbsolute(options.configPath) ? options.configPath : resolve(cwd, options.configPath);
+      if (existsSync(explicitPath)) {
+        return this.parseConfigFile(explicitPath);
+      }
+      throw new Error(`Configuration file not found at: ${explicitPath}`);
+    }
+    const candidatePaths = [
+      resolve(cwd, "contextwise.json"),
+      resolve(cwd, ".contextwise.json"),
+      resolve(cwd, ".contextwise/config.json"),
+      resolve(homedir(), ".contextwise/config.json")
+    ];
+    for (const candidate of candidatePaths) {
+      if (existsSync(candidate)) {
+        logger.debug(`Loaded configuration from ${candidate}`);
+        return this.parseConfigFile(candidate);
+      }
+    }
+    if (options.autoImport !== false) {
+      const imported = this.autoImportClientConfigs(cwd);
+      if (imported && Object.keys(imported.upstreams).length > 0) {
+        logger.info(`Auto-discovered MCP servers from existing client configurations`);
+        return imported;
+      }
+    }
+    logger.debug("No configuration file found. Using defaults.");
+    return ContextWiseConfigSchema.parse({});
+  }
+  /**
+   * Parses and validates a JSON file against ContextWiseConfigSchema.
+   */
+  static parseConfigFile(filePath) {
+    try {
+      const raw = readFileSync(filePath, "utf-8");
+      const parsed = JSON.parse(raw);
+      return ContextWiseConfigSchema.parse(parsed);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      throw new Error(`Failed to parse config at ${filePath}: ${msg}`);
+    }
+  }
+  /**
+   * Scans for Cursor and Claude Desktop configs to auto-import upstreams.
+   */
+  static autoImportClientConfigs(cwd) {
+    const upstreams = {};
+    const cursorMcp = resolve(cwd, ".cursor", "mcp.json");
+    if (existsSync(cursorMcp)) {
+      try {
+        const raw = JSON.parse(readFileSync(cursorMcp, "utf-8"));
+        if (raw.mcpServers && typeof raw.mcpServers === "object") {
+          for (const [name, server] of Object.entries(raw.mcpServers)) {
+            if (name === "contextwise") continue;
+            const s = server;
+            if (typeof s.command === "string") {
+              upstreams[name] = {
+                command: s.command,
+                args: Array.isArray(s.args) ? s.args : [],
+                env: s.env ?? {},
+                autoRestart: true
+              };
+            } else if (typeof s.url === "string") {
+              upstreams[name] = {
+                url: s.url,
+                headers: s.headers ?? {},
+                transport: "auto",
+                autoReconnect: true
+              };
+            }
+          }
+        }
+      } catch (err) {
+        logger.warn(`Failed reading ${cursorMcp}: ${err}`);
+      }
+    }
+    const claudePath = this.getClaudeDesktopConfigPath();
+    if (claudePath && existsSync(claudePath)) {
+      try {
+        const raw = JSON.parse(readFileSync(claudePath, "utf-8"));
+        if (raw.mcpServers && typeof raw.mcpServers === "object") {
+          for (const [name, server] of Object.entries(raw.mcpServers)) {
+            if (name === "contextwise") continue;
+            const s = server;
+            if (typeof s.command === "string" && !upstreams[name]) {
+              upstreams[name] = {
+                command: s.command,
+                args: Array.isArray(s.args) ? s.args : [],
+                env: s.env ?? {},
+                autoRestart: true
+              };
+            } else if (typeof s.url === "string" && !upstreams[name]) {
+              upstreams[name] = {
+                url: s.url,
+                headers: s.headers ?? {},
+                transport: "auto",
+                autoReconnect: true
+              };
+            }
+          }
+        }
+      } catch (err) {
+        logger.warn(`Failed reading Claude config at ${claudePath}: ${err}`);
+      }
+    }
+    if (Object.keys(upstreams).length === 0) {
+      return null;
+    }
+    return ContextWiseConfigSchema.parse({
+      upstreams
+    });
+  }
+  static getClaudeDesktopConfigPath() {
+    const platform2 = process.platform;
+    const home = homedir();
+    if (platform2 === "win32") {
+      const appData = process.env.APPDATA || join(home, "AppData", "Roaming");
+      return join(appData, "Claude", "claude_desktop_config.json");
+    } else if (platform2 === "darwin") {
+      return join(home, "Library", "Application Support", "Claude", "claude_desktop_config.json");
+    } else {
+      return join(home, ".config", "Claude", "claude_desktop_config.json");
+    }
+  }
+};
+
+// src/vault/file_driver.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync3, renameSync, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
+import { homedir as homedir3 } from "os";
+import { dirname as dirname2, join as join3 } from "path";
+
+// src/vault/crypto.ts
+import {
+  createCipheriv,
+  createDecipheriv,
+  createHash,
+  createPrivateKey,
+  createPublicKey,
+  diffieHellman,
+  generateKeyPairSync,
+  pbkdf2,
+  randomBytes
+} from "crypto";
+import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { arch, homedir as homedir2, hostname, platform, userInfo } from "os";
+import { join as join2 } from "path";
+function encryptAesGcm(plaintext, key) {
+  if (key.length !== 32) {
+    throw new Error(`Invalid AES-256 key length: expected 32 bytes, got ${key.length}`);
+  }
+  const iv = randomBytes(12);
+  const cipher = createCipheriv("aes-256-gcm", key, iv);
+  let ciphertext = cipher.update(plaintext, "utf-8", "base64");
+  ciphertext += cipher.final("base64");
+  const authTag = cipher.getAuthTag();
+  return {
+    iv: iv.toString("base64"),
+    authTag: authTag.toString("base64"),
+    ciphertext
+  };
+}
+function decryptAesGcm(ciphertext, key, ivBase64, authTagBase64) {
+  if (key.length !== 32) {
+    throw new Error(`Invalid AES-256 key length: expected 32 bytes, got ${key.length}`);
+  }
+  const iv = Buffer.from(ivBase64, "base64");
+  const authTag = Buffer.from(authTagBase64, "base64");
+  const decipher = createDecipheriv("aes-256-gcm", key, iv);
+  decipher.setAuthTag(authTag);
+  let decrypted = decipher.update(ciphertext, "base64", "utf-8");
+  decrypted += decipher.final("utf-8");
+  return decrypted;
+}
+var VAULT_PBKDF2_ITERATIONS = 21e4;
+function deriveKeyFromPassphrase(passphrase, salt, iterations = VAULT_PBKDF2_ITERATIONS) {
+  return new Promise((resolve2, reject) => {
+    pbkdf2(passphrase, salt, iterations, 32, "sha512", (err, derivedKey) => {
+      if (err) reject(err);
+      else resolve2(derivedKey);
+    });
+  });
+}
+async function getOrCreateMachineKey() {
+  const saltDir = join2(homedir2(), ".contextwise");
+  const saltPath = join2(saltDir, ".machine_salt");
+  let salt;
+  if (existsSync2(saltPath)) {
+    salt = readFileSync2(saltPath);
+  } else {
+    mkdirSync(saltDir, { recursive: true });
+    salt = randomBytes(32);
+    writeFileSync(saltPath, salt, { mode: 384 });
+  }
+  if (process.env.CONTEXTWISE_VAULT_PASSPHRASE) {
+    return deriveKeyFromPassphrase(process.env.CONTEXTWISE_VAULT_PASSPHRASE, salt, VAULT_PBKDF2_ITERATIONS);
+  }
+  const user = (() => {
+    try {
+      return userInfo().username;
+    } catch {
+      return "default_user";
+    }
+  })();
+  const machineId = `${hostname()}-${user}-${platform()}-${arch()}-contextwise-vault-v1`;
+  return deriveKeyFromPassphrase(machineId, salt, VAULT_PBKDF2_ITERATIONS);
+}
+function generateKeyPairX25519() {
+  const { publicKey, privateKey } = generateKeyPairSync("x25519", {
+    publicKeyEncoding: { type: "spki", format: "pem" },
+    privateKeyEncoding: { type: "pkcs8", format: "pem" }
+  });
+  return { publicKey, privateKey };
+}
+function deriveSharedSecretX25519(privateKeyPem, publicKeyPem) {
+  const privateKey = createPrivateKey(privateKeyPem);
+  const publicKey = createPublicKey(publicKeyPem);
+  const shared = diffieHellman({
+    privateKey,
+    publicKey
+  });
+  return createHash("sha256").update(shared).digest();
+}
+
+// src/vault/file_driver.ts
+function getDefaultVaultFilePath() {
+  if (process.env.CONTEXTWISE_VAULT_PATH) {
+    return process.env.CONTEXTWISE_VAULT_PATH;
+  }
+  if (process.env.CONTEXTWISE_STORAGE_DIR) {
+    return join3(process.env.CONTEXTWISE_STORAGE_DIR, "vault.enc.json");
+  }
+  return join3(homedir3(), ".contextwise", "vault.enc.json");
+}
+var EncryptedFileVaultDriver = class {
+  name = "encrypted_file";
+  filePath;
+  keyPromise;
+  cache = null;
+  constructor(filePath, customKey) {
+    this.filePath = filePath ?? getDefaultVaultFilePath();
+    this.keyPromise = customKey ? Promise.resolve(customKey) : getOrCreateMachineKey();
+  }
+  async isAvailable() {
+    return true;
+  }
+  async load() {
+    if (this.cache) {
+      return this.cache;
+    }
+    this.cache = /* @__PURE__ */ new Map();
+    if (!existsSync3(this.filePath)) {
+      return this.cache;
+    }
+    try {
+      const raw = readFileSync3(this.filePath, "utf-8");
+      const payload = JSON.parse(raw);
+      if (payload.cipher !== "aes-256-gcm" || !payload.data) {
+        logger.warn(`Corrupt or incompatible vault file at ${this.filePath}`);
+        return this.cache;
+      }
+      const key = await this.keyPromise;
+      const decryptedJson = decryptAesGcm(payload.data, key, payload.iv, payload.authTag);
+      const entries = JSON.parse(decryptedJson);
+      for (const [k, v] of Object.entries(entries)) {
+        this.cache.set(k, v);
+      }
+    } catch (err) {
+      logger.warn(`Failed to decrypt vault file at ${this.filePath}: ${err}`);
+    }
+    return this.cache;
+  }
+  async persist() {
+    if (!this.cache) return;
+    const dir = dirname2(this.filePath);
+    if (!existsSync3(dir)) {
+      mkdirSync2(dir, { recursive: true });
+    }
+    const key = await this.keyPromise;
+    const entries = {};
+    for (const [k, v] of this.cache.entries()) {
+      entries[k] = v;
+    }
+    const plaintext = JSON.stringify(entries);
+    const { iv, authTag, ciphertext } = encryptAesGcm(plaintext, key);
+    const payload = {
+      version: 1,
+      kdf: {
+        algorithm: "pbkdf2-sha512",
+        salt: "machine-bound",
+        iterations: VAULT_PBKDF2_ITERATIONS
+      },
+      cipher: "aes-256-gcm",
+      iv,
+      authTag,
+      data: ciphertext
+    };
+    const tempPath = `${this.filePath}.${Date.now()}.tmp`;
+    writeFileSync2(tempPath, JSON.stringify(payload, null, 2), { mode: 384, encoding: "utf-8" });
+    try {
+      renameSync(tempPath, this.filePath);
+    } catch {
+      writeFileSync2(this.filePath, JSON.stringify(payload, null, 2), { mode: 384, encoding: "utf-8" });
+      try {
+        unlinkSync(tempPath);
+      } catch {
+      }
+    }
+  }
+  async get(key) {
+    const store = await this.load();
+    const entry = store.get(key);
+    return entry ? entry.value : null;
+  }
+  async set(key, value, scope = "personal") {
+    const store = await this.load();
+    const now = Date.now();
+    const existing = store.get(key);
+    store.set(key, {
+      value,
+      metadata: {
+        key,
+        scope,
+        backend: this.name,
+        createdAt: existing?.metadata.createdAt ?? now,
+        updatedAt: now
+      }
+    });
+    await this.persist();
+    logger.debug(`Stored secret "${key}" in ${this.name} vault`);
+  }
+  async delete(key) {
+    const store = await this.load();
+    if (!store.has(key)) {
+      return false;
+    }
+    store.delete(key);
+    await this.persist();
+    logger.debug(`Deleted secret "${key}" from ${this.name} vault`);
+    return true;
+  }
+  async list() {
+    const store = await this.load();
+    return Array.from(store.values()).map((e) => e.metadata);
+  }
+  /**
+   * Resets and clears all cached and persisted secrets.
+   */
+  async clear() {
+    this.cache = /* @__PURE__ */ new Map();
+    if (existsSync3(this.filePath)) {
+      try {
+        unlinkSync(this.filePath);
+      } catch {
+      }
+    }
+  }
+};
+
+// src/cloud/crypto.ts
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
+import { homedir as homedir4 } from "os";
+import { join as join4 } from "path";
+import { randomBytes as randomBytes2 } from "crypto";
+function createEnvelope(workspaceKey, recipientPublicKeyPem) {
+  const ephemeral = generateKeyPairX25519();
+  const sharedKey = deriveSharedSecretX25519(ephemeral.privateKey, recipientPublicKeyPem);
+  const { iv, authTag, ciphertext } = encryptAesGcm(
+    workspaceKey.toString("base64"),
+    sharedKey
+  );
+  return {
+    recipientPublicKey: recipientPublicKeyPem,
+    ephemeralPublicKey: ephemeral.publicKey,
+    iv,
+    authTag,
+    ciphertext
+  };
+}
+function openEnvelope(envelope, recipientPrivateKeyPem) {
+  const sharedKey = deriveSharedSecretX25519(
+    recipientPrivateKeyPem,
+    envelope.ephemeralPublicKey
+  );
+  const decryptedBase64 = decryptAesGcm(
+    envelope.ciphertext,
+    sharedKey,
+    envelope.iv,
+    envelope.authTag
+  );
+  return Buffer.from(decryptedBase64, "base64");
+}
+function getOrCreateDeviceIdentity(storageDir) {
+  const dir = storageDir || process.env.CONTEXTWISE_STORAGE_DIR || join4(homedir4(), ".contextwise");
+  const filePath = join4(dir, "device.json");
+  if (existsSync4(filePath)) {
+    try {
+      const data = JSON.parse(readFileSync4(filePath, "utf-8"));
+      if (data.deviceId && data.publicKey && data.privateKey) {
+        return data;
+      }
+    } catch {
+    }
+  }
+  if (!existsSync4(dir)) {
+    mkdirSync3(dir, { recursive: true });
+  }
+  const { publicKey, privateKey } = generateKeyPairX25519();
+  const deviceId = `cw_dev_${randomBytes2(8).toString("hex")}`;
+  const identity = {
+    deviceId,
+    publicKey,
+    privateKey
+  };
+  writeFileSync3(filePath, JSON.stringify(identity, null, 2), {
+    mode: 384,
+    encoding: "utf-8"
+  });
+  return identity;
+}
+
+// src/cloud/sync_manager.ts
+var SyncManager = class {
+  syncStatePath;
+  localConfigPath;
+  constructor(storageDir, localConfigPath) {
+    const dir = storageDir || process.env.CONTEXTWISE_STORAGE_DIR || join5(homedir5(), ".contextwise");
+    this.syncStatePath = join5(dir, "sync.json");
+    this.localConfigPath = localConfigPath;
+  }
+  loadSyncState() {
+    if (existsSync5(this.syncStatePath)) {
+      try {
+        const raw = readFileSync5(this.syncStatePath, "utf-8");
+        return JSON.parse(raw);
+      } catch {
+      }
+    }
+    return {
+      workspaceId: "ws_default",
+      revision: 0,
+      lastSyncedAt: 0
+    };
+  }
+  saveSyncState(state) {
+    writeFileSync4(this.syncStatePath, JSON.stringify(state, null, 2), {
+      mode: 384,
+      encoding: "utf-8"
+    });
+  }
+  /**
+   * Pushes local configuration and encrypted vault payload to the cloud.
+   */
+  async push(workspaceId, receipt) {
+    const state = this.loadSyncState();
+    const wsId = workspaceId || state.workspaceId;
+    const device = getOrCreateDeviceIdentity();
+    const localConfig = ConfigLoader.load();
+    const vaultPath = getDefaultVaultFilePath();
+    let encryptedVault;
+    if (existsSync5(vaultPath)) {
+      try {
+        const rawVault = readFileSync5(vaultPath, "utf-8");
+        encryptedVault = JSON.parse(rawVault);
+      } catch {
+        encryptedVault = this.createEmptyEncryptedVault();
+      }
+    } else {
+      encryptedVault = this.createEmptyEncryptedVault();
+    }
+    const payload = {
+      workspaceId: wsId,
+      deviceId: device.deviceId,
+      baseRevision: state.revision,
+      config: localConfig,
+      encryptedVault,
+      timestamp: Date.now()
+    };
+    const result = await cloudClient.pushSync(payload, receipt);
+    if (result.status === "committed") {
+      state.workspaceId = wsId;
+      state.revision = result.revision;
+      state.lastSyncedAt = Date.now();
+      this.saveSyncState(state);
+      logger.info(`Successfully pushed revision #${result.revision} to ContextWise Cloud.`);
+    }
+    return result;
+  }
+  /**
+   * Pulls the latest cloud configuration and merges upstream servers.
+   */
+  async pull(workspaceId, receipt) {
+    const state = this.loadSyncState();
+    const wsId = workspaceId || state.workspaceId;
+    const pullResult = await cloudClient.pullSync(wsId, state.revision, receipt);
+    if (!pullResult) {
+      logger.info("Local configuration is already up to date.");
+      return null;
+    }
+    if (pullResult.config && pullResult.config.upstreams) {
+      this.mergeConfigIntoLocal(pullResult.config);
+    }
+    if (pullResult.encryptedVault && pullResult.encryptedVault.data) {
+      const vaultPath = getDefaultVaultFilePath();
+      writeFileSync4(vaultPath, JSON.stringify(pullResult.encryptedVault, null, 2), {
+        mode: 384,
+        encoding: "utf-8"
+      });
+    }
+    state.revision = pullResult.revision;
+    state.lastSyncedAt = Date.now();
+    this.saveSyncState(state);
+    logger.info(`Pulled and applied cloud revision #${pullResult.revision}.`);
+    return pullResult;
+  }
+  /**
+   * Semantically merges remote configuration into local contextwise.json.
+   */
+  mergeConfigIntoLocal(remoteConfig) {
+    const validatedRemote = ContextWiseConfigSchema.parse(remoteConfig);
+    const configPath = this.localConfigPath || process.env.CONTEXTWISE_CONFIG || join5(process.cwd(), "contextwise.json");
+    let localConfig;
+    if (existsSync5(configPath)) {
+      try {
+        localConfig = ContextWiseConfigSchema.parse(JSON.parse(readFileSync5(configPath, "utf-8")));
+      } catch {
+        localConfig = ContextWiseConfigSchema.parse({});
+      }
+    } else {
+      localConfig = ContextWiseConfigSchema.parse({});
+    }
+    for (const [name, s] of Object.entries(validatedRemote.upstreams || {})) {
+      if (isStdioUpstream(s) && !localConfig.upstreams[name]) {
+        logger.warn(
+          `[Cloud Sync Security] Remote configuration contains new stdio upstream "${name}" (${s.command}). Verify this server in contextwise.json before execution.`
+        );
+      }
+    }
+    const mergedUpstreams = {
+      ...validatedRemote.upstreams || {},
+      ...localConfig.upstreams || {}
+    };
+    const merged = {
+      ...localConfig,
+      upstreams: mergedUpstreams
+    };
+    writeFileSync4(configPath, JSON.stringify(merged, null, 2), "utf-8");
+  }
+  createEmptyEncryptedVault() {
+    return {
+      version: 1,
+      kdf: {
+        algorithm: "pbkdf2-sha512",
+        salt: "empty",
+        iterations: 5e4
+      },
+      cipher: "aes-256-gcm",
+      iv: "",
+      authTag: "",
+      data: ""
+    };
+  }
+  getStatus() {
+    const token = cloudClient.getToken();
+    const state = this.loadSyncState();
+    const device = getOrCreateDeviceIdentity();
+    return {
+      isLoggedIn: cloudClient.isAuthenticated(),
+      userEmail: token?.email,
+      workspaceId: state.workspaceId,
+      revision: state.revision,
+      lastSyncedAt: state.lastSyncedAt,
+      deviceId: device.deviceId
+    };
+  }
+};
+var syncManager = new SyncManager();
+
+export {
+  StdioUpstreamConfigSchema,
+  HttpUpstreamConfigSchema,
+  UpstreamServerConfigSchema,
+  warnIfInsecureHttp,
+  isStdioUpstream,
+  isHttpUpstream,
+  ProxyConfigSchema,
+  RoutingConfigSchema,
+  GuardrailsConfigSchema,
+  ContextWiseConfigSchema,
+  ConfigLoader,
+  encryptAesGcm,
+  decryptAesGcm,
+  VAULT_PBKDF2_ITERATIONS,
+  deriveKeyFromPassphrase,
+  getOrCreateMachineKey,
+  generateKeyPairX25519,
+  deriveSharedSecretX25519,
+  getDefaultVaultFilePath,
+  EncryptedFileVaultDriver,
+  createEnvelope,
+  openEnvelope,
+  getOrCreateDeviceIdentity,
+  SyncManager,
+  syncManager
+};
+//# sourceMappingURL=chunk-OYCA37PJ.js.map