@albinocrabs/o-switcher 0.3.0 → 0.4.0

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## 0.4.0
+
+### Minor Changes
+
+- Add HTTP proxy for automatic API key rotation on 429
+  - Proxy starts automatically inside plugin — zero config needed
+  - Intercepts 429 rate limits and retries with next profile's API key
+  - Client never sees the rate limit — switching is transparent
+  - Also available as standalone CLI: `npx o-switcher-proxy`
+  - TUI sidebar now shows proxy status and active profile
+
 ## 0.3.0
 
 ### Minor Changes

package/dist/{chunk-XXH633FY.js → chunk-2EYMYNKS.js}

@@ -1,11 +1,10 @@
+import { PROFILES_PATH, loadProfiles, removeProfile, saveProfiles, listProfiles, addProfile } from './chunk-HAEEX3KB.js';
 import { z } from 'zod';
-import pino from 'pino';
-import crypto from 'crypto';
 import { EventEmitter } from 'eventemitter3';
 import { CircuitState, ConsecutiveBreaker, CountBreaker, BrokenCircuitError, IsolatedCircuitError, circuitBreaker, handleAll } from 'cockatiel';
 import PQueue from 'p-queue';
 import { tool } from '@opencode-ai/plugin/tool';
-import { readFile, mkdir, writeFile, rename, watch } from 'fs/promises';
+import { mkdir, writeFile, rename, watch, readFile } from 'fs/promises';
 import { homedir } from 'os';
 import { join, dirname } from 'path';
 
@@ -305,37 +304,6 @@ var TARGET_STATES = [
   "Draining",
   "Disabled"
 ];
-var REDACT_PATHS = [
-  "api_key",
-  "token",
-  "secret",
-  "password",
-  "authorization",
-  "credential",
-  "credentials",
-  "*.api_key",
-  "*.token",
-  "*.secret",
-  "*.password",
-  "*.authorization",
-  "*.credential",
-  "*.credentials"
-];
-var createAuditLogger = (options) => {
-  const opts = {
-    level: options?.level ?? "info",
-    redact: {
-      paths: [...REDACT_PATHS],
-      censor: "[Redacted]"
-    }
-  };
-  if (options?.destination) {
-    return pino(opts, options.destination);
-  }
-  return pino(opts);
-};
-var createRequestLogger = (baseLogger, requestId) => baseLogger.child({ request_id: requestId });
-var generateCorrelationId = () => crypto.randomUUID();
 var RateLimitedSchema = z.object({
   class: z.literal("RateLimited"),
   retryable: z.literal(true),
@@ -1427,72 +1395,6 @@ var createOperatorTools = (deps) => ({
     }
   })
 });
-var PROFILES_DIR = join(homedir(), ".local", "share", "o-switcher");
-var PROFILES_PATH = join(PROFILES_DIR, "profiles.json");
-var loadProfiles = async (path = PROFILES_PATH) => {
-  try {
-    const content = await readFile(path, "utf-8");
-    return JSON.parse(content);
-  } catch (err) {
-    const code = err.code;
-    if (code === "ENOENT") {
-      return {};
-    }
-    throw err;
-  }
-};
-var saveProfiles = async (store, path = PROFILES_PATH, logger) => {
-  const dir = dirname(path);
-  await mkdir(dir, { recursive: true });
-  const tmpPath = `${path}.tmp`;
-  await writeFile(tmpPath, JSON.stringify(store, null, 2), "utf-8");
-  await rename(tmpPath, path);
-  logger?.info({ path }, "Profiles saved to disk");
-};
-var credentialsMatch = (a, b) => {
-  if (a.type !== b.type) return false;
-  if (a.type === "api-key" && b.type === "api-key") {
-    return a.key === b.key;
-  }
-  if (a.type === "oauth" && b.type === "oauth") {
-    return a.refresh === b.refresh && a.access === b.access && a.expires === b.expires && a.accountId === b.accountId;
-  }
-  return false;
-};
-var addProfile = (store, provider, credentials) => {
-  const isDuplicate = Object.values(store).some(
-    (entry2) => entry2.provider === provider && credentialsMatch(entry2.credentials, credentials)
-  );
-  if (isDuplicate) {
-    return store;
-  }
-  const id = nextProfileId(store, provider);
-  const entry = {
-    id,
-    provider,
-    type: credentials.type,
-    credentials,
-    created: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  return { ...store, [id]: entry };
-};
-var removeProfile = (store, id) => {
-  if (store[id] === void 0) {
-    return { store, removed: false };
-  }
-  const { [id]: _removed, ...rest } = store;
-  return { store: rest, removed: true };
-};
-var listProfiles = (store) => {
-  return Object.values(store).sort(
-    (a, b) => new Date(a.created).getTime() - new Date(b.created).getTime()
-  );
-};
-var nextProfileId = (store, provider) => {
-  const prefix = `${provider}-`;
-  const maxN = Object.keys(store).filter((key) => key.startsWith(prefix)).map((key) => Number(key.slice(prefix.length))).filter((n) => !Number.isNaN(n)).reduce((max, n) => Math.max(max, n), 0);
-  return `${provider}-${maxN + 1}`;
-};
 var AUTH_JSON_PATH = join(homedir(), ".local", "share", "opencode", "auth.json");
 var AUTH_DIR = join(homedir(), ".local", "share", "opencode");
 var isAuthFile = (filename) => filename === "auth.json" || /^auth-work\d+\.json$/.test(filename);
@@ -1760,4 +1662,4 @@ var createProfileTools = (options) => ({
   })
 });
 
-export { ADMISSION_RESULTS, BackoffConfigSchema, ConfigValidationError, DEFAULT_ALPHA, DEFAULT_BACKOFF_BASE_MS, DEFAULT_BACKOFF_JITTER, DEFAULT_BACKOFF_MAX_MS, DEFAULT_BACKOFF_MULTIPLIER, DEFAULT_BACKOFF_PARAMS, DEFAULT_FAILOVER_BUDGET, DEFAULT_RETRY, DEFAULT_RETRY_BUDGET, DEFAULT_TIMEOUT_MS, DualBreaker, EXCLUSION_REASONS, ErrorClassSchema, INITIAL_HEALTH_SCORE, REDACT_PATHS, SwitcherConfigSchema, TARGET_STATES, TargetConfigSchema, TargetRegistry, addProfile, applyConfigDiff, checkHardRejects, computeBackoffMs, computeConfigDiff, computeCooldownMs, computeScore, createAdmissionController, createAuditLogger, createAuthWatcher, createCircuitBreaker, createConcurrencyTracker, createCooldownManager, createFailoverOrchestrator, createLogSubscriber, createOperatorTools, createProfileTools, createRegistry, createRequestLogger, createRequestTraceBuffer, createRetryPolicy, createRoutingEventBus, disableTarget, discoverTargets, discoverTargetsFromProfiles, drainTarget, generateCorrelationId, getExclusionReason, getTargetStateTransition, inspectRequest, isRetryable, listProfiles, listTargets, loadProfiles, nextProfileId, normalizeLatency, pauseTarget, reloadConfig, removeProfile, resumeTarget, saveProfiles, selectTarget, switchProfile, switchToNextProfile, updateHealthScore, updateLatencyEma, validateConfig };
+export { ADMISSION_RESULTS, BackoffConfigSchema, ConfigValidationError, DEFAULT_ALPHA, DEFAULT_BACKOFF_BASE_MS, DEFAULT_BACKOFF_JITTER, DEFAULT_BACKOFF_MAX_MS, DEFAULT_BACKOFF_MULTIPLIER, DEFAULT_BACKOFF_PARAMS, DEFAULT_FAILOVER_BUDGET, DEFAULT_RETRY, DEFAULT_RETRY_BUDGET, DEFAULT_TIMEOUT_MS, DualBreaker, EXCLUSION_REASONS, ErrorClassSchema, INITIAL_HEALTH_SCORE, SwitcherConfigSchema, TARGET_STATES, TargetConfigSchema, TargetRegistry, applyConfigDiff, checkHardRejects, computeBackoffMs, computeConfigDiff, computeCooldownMs, computeScore, createAdmissionController, createAuthWatcher, createCircuitBreaker, createConcurrencyTracker, createCooldownManager, createFailoverOrchestrator, createLogSubscriber, createOperatorTools, createProfileTools, createRegistry, createRequestTraceBuffer, createRetryPolicy, createRoutingEventBus, disableTarget, discoverTargets, discoverTargetsFromProfiles, drainTarget, getExclusionReason, getTargetStateTransition, inspectRequest, isRetryable, listTargets, normalizeLatency, pauseTarget, reloadConfig, resumeTarget, selectTarget, switchProfile, switchToNextProfile, updateHealthScore, updateLatencyEma, validateConfig };

package/dist/chunk-BHHR2U5B.cjs

@@ -0,0 +1,123 @@
+'use strict';
+
+var pino = require('pino');
+var crypto = require('crypto');
+var promises = require('fs/promises');
+var os = require('os');
+var path = require('path');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var pino__default = /*#__PURE__*/_interopDefault(pino);
+var crypto__default = /*#__PURE__*/_interopDefault(crypto);
+
+// src/audit/logger.ts
+var REDACT_PATHS = [
+  "api_key",
+  "token",
+  "secret",
+  "password",
+  "authorization",
+  "credential",
+  "credentials",
+  "*.api_key",
+  "*.token",
+  "*.secret",
+  "*.password",
+  "*.authorization",
+  "*.credential",
+  "*.credentials"
+];
+var createAuditLogger = (options) => {
+  const opts = {
+    level: options?.level ?? "info",
+    redact: {
+      paths: [...REDACT_PATHS],
+      censor: "[Redacted]"
+    }
+  };
+  if (options?.destination) {
+    return pino__default.default(opts, options.destination);
+  }
+  return pino__default.default(opts);
+};
+var createRequestLogger = (baseLogger, requestId) => baseLogger.child({ request_id: requestId });
+var generateCorrelationId = () => crypto__default.default.randomUUID();
+var PROFILES_DIR = path.join(os.homedir(), ".local", "share", "o-switcher");
+var PROFILES_PATH = path.join(PROFILES_DIR, "profiles.json");
+var loadProfiles = async (path = PROFILES_PATH) => {
+  try {
+    const content = await promises.readFile(path, "utf-8");
+    return JSON.parse(content);
+  } catch (err) {
+    const code = err.code;
+    if (code === "ENOENT") {
+      return {};
+    }
+    throw err;
+  }
+};
+var saveProfiles = async (store, path$1 = PROFILES_PATH, logger) => {
+  const dir = path.dirname(path$1);
+  await promises.mkdir(dir, { recursive: true });
+  const tmpPath = `${path$1}.tmp`;
+  await promises.writeFile(tmpPath, JSON.stringify(store, null, 2), "utf-8");
+  await promises.rename(tmpPath, path$1);
+  logger?.info({ path: path$1 }, "Profiles saved to disk");
+};
+var credentialsMatch = (a, b) => {
+  if (a.type !== b.type) return false;
+  if (a.type === "api-key" && b.type === "api-key") {
+    return a.key === b.key;
+  }
+  if (a.type === "oauth" && b.type === "oauth") {
+    return a.refresh === b.refresh && a.access === b.access && a.expires === b.expires && a.accountId === b.accountId;
+  }
+  return false;
+};
+var addProfile = (store, provider, credentials) => {
+  const isDuplicate = Object.values(store).some(
+    (entry2) => entry2.provider === provider && credentialsMatch(entry2.credentials, credentials)
+  );
+  if (isDuplicate) {
+    return store;
+  }
+  const id = nextProfileId(store, provider);
+  const entry = {
+    id,
+    provider,
+    type: credentials.type,
+    credentials,
+    created: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  return { ...store, [id]: entry };
+};
+var removeProfile = (store, id) => {
+  if (store[id] === void 0) {
+    return { store, removed: false };
+  }
+  const { [id]: _removed, ...rest } = store;
+  return { store: rest, removed: true };
+};
+var listProfiles = (store) => {
+  return Object.values(store).sort(
+    (a, b) => new Date(a.created).getTime() - new Date(b.created).getTime()
+  );
+};
+var nextProfileId = (store, provider) => {
+  const prefix = `${provider}-`;
+  const maxN = Object.keys(store).filter((key) => key.startsWith(prefix)).map((key) => Number(key.slice(prefix.length))).filter((n) => !Number.isNaN(n)).reduce((max, n) => Math.max(max, n), 0);
+  return `${provider}-${maxN + 1}`;
+};
+
+exports.PROFILES_PATH = PROFILES_PATH;
+exports.REDACT_PATHS = REDACT_PATHS;
+exports.addProfile = addProfile;
+exports.createAuditLogger = createAuditLogger;
+exports.createRequestLogger = createRequestLogger;
+exports.generateCorrelationId = generateCorrelationId;
+exports.listProfiles = listProfiles;
+exports.loadProfiles = loadProfiles;
+exports.nextProfileId = nextProfileId;
+exports.removeProfile = removeProfile;
+exports.saveProfiles = saveProfiles;

package/dist/chunk-HAEEX3KB.js

@@ -0,0 +1,106 @@
+import pino from 'pino';
+import crypto from 'crypto';
+import { readFile, mkdir, writeFile, rename } from 'fs/promises';
+import { homedir } from 'os';
+import { join, dirname } from 'path';
+
+// src/audit/logger.ts
+var REDACT_PATHS = [
+  "api_key",
+  "token",
+  "secret",
+  "password",
+  "authorization",
+  "credential",
+  "credentials",
+  "*.api_key",
+  "*.token",
+  "*.secret",
+  "*.password",
+  "*.authorization",
+  "*.credential",
+  "*.credentials"
+];
+var createAuditLogger = (options) => {
+  const opts = {
+    level: options?.level ?? "info",
+    redact: {
+      paths: [...REDACT_PATHS],
+      censor: "[Redacted]"
+    }
+  };
+  if (options?.destination) {
+    return pino(opts, options.destination);
+  }
+  return pino(opts);
+};
+var createRequestLogger = (baseLogger, requestId) => baseLogger.child({ request_id: requestId });
+var generateCorrelationId = () => crypto.randomUUID();
+var PROFILES_DIR = join(homedir(), ".local", "share", "o-switcher");
+var PROFILES_PATH = join(PROFILES_DIR, "profiles.json");
+var loadProfiles = async (path = PROFILES_PATH) => {
+  try {
+    const content = await readFile(path, "utf-8");
+    return JSON.parse(content);
+  } catch (err) {
+    const code = err.code;
+    if (code === "ENOENT") {
+      return {};
+    }
+    throw err;
+  }
+};
+var saveProfiles = async (store, path = PROFILES_PATH, logger) => {
+  const dir = dirname(path);
+  await mkdir(dir, { recursive: true });
+  const tmpPath = `${path}.tmp`;
+  await writeFile(tmpPath, JSON.stringify(store, null, 2), "utf-8");
+  await rename(tmpPath, path);
+  logger?.info({ path }, "Profiles saved to disk");
+};
+var credentialsMatch = (a, b) => {
+  if (a.type !== b.type) return false;
+  if (a.type === "api-key" && b.type === "api-key") {
+    return a.key === b.key;
+  }
+  if (a.type === "oauth" && b.type === "oauth") {
+    return a.refresh === b.refresh && a.access === b.access && a.expires === b.expires && a.accountId === b.accountId;
+  }
+  return false;
+};
+var addProfile = (store, provider, credentials) => {
+  const isDuplicate = Object.values(store).some(
+    (entry2) => entry2.provider === provider && credentialsMatch(entry2.credentials, credentials)
+  );
+  if (isDuplicate) {
+    return store;
+  }
+  const id = nextProfileId(store, provider);
+  const entry = {
+    id,
+    provider,
+    type: credentials.type,
+    credentials,
+    created: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  return { ...store, [id]: entry };
+};
+var removeProfile = (store, id) => {
+  if (store[id] === void 0) {
+    return { store, removed: false };
+  }
+  const { [id]: _removed, ...rest } = store;
+  return { store: rest, removed: true };
+};
+var listProfiles = (store) => {
+  return Object.values(store).sort(
+    (a, b) => new Date(a.created).getTime() - new Date(b.created).getTime()
+  );
+};
+var nextProfileId = (store, provider) => {
+  const prefix = `${provider}-`;
+  const maxN = Object.keys(store).filter((key) => key.startsWith(prefix)).map((key) => Number(key.slice(prefix.length))).filter((n) => !Number.isNaN(n)).reduce((max, n) => Math.max(max, n), 0);
+  return `${provider}-${maxN + 1}`;
+};
+
+export { PROFILES_PATH, REDACT_PATHS, addProfile, createAuditLogger, createRequestLogger, generateCorrelationId, listProfiles, loadProfiles, nextProfileId, removeProfile, saveProfiles };

package/dist/chunk-I6RDAZBR.js

@@ -0,0 +1,231 @@
+import { createAuditLogger, loadProfiles } from './chunk-HAEEX3KB.js';
+import { mkdir, writeFile, rename } from 'fs/promises';
+import { join, dirname } from 'path';
+import { homedir } from 'os';
+import { createServer } from 'http';
+
+var STATE_DIR = join(homedir(), ".local", "share", "o-switcher");
+var STATE_FILE = join(STATE_DIR, "tui-state.json");
+var STATE_TMP = join(STATE_DIR, "tui-state.json.tmp");
+var writeStateAtomic = async (state) => {
+  await mkdir(dirname(STATE_FILE), { recursive: true });
+  const json = JSON.stringify(state);
+  await writeFile(STATE_TMP, json, "utf8");
+  await rename(STATE_TMP, STATE_FILE);
+};
+var createStateWriter = (debounceMs = 500) => {
+  let pending;
+  let timer;
+  let writePromise = Promise.resolve();
+  const doWrite = () => {
+    if (!pending) return;
+    const snapshot = pending;
+    pending = void 0;
+    writePromise = writeStateAtomic(snapshot).catch(() => void 0);
+  };
+  const write = (state) => {
+    pending = state;
+    if (timer) clearTimeout(timer);
+    timer = setTimeout(doWrite, debounceMs);
+  };
+  const flush = async () => {
+    if (timer) {
+      clearTimeout(timer);
+      timer = void 0;
+    }
+    doWrite();
+    await writePromise;
+  };
+  return { write, flush };
+};
+var DEFAULT_CONFIG = {
+  port: 4444,
+  upstream: "https://api.openai.com",
+  maxRetries: 3,
+  provider: "openai"
+};
+var buildProfilePool = (profiles) => profiles.sort((a, b) => a.consecutiveFailures - b.consecutiveFailures);
+var getBearerToken = (profile) => {
+  const creds = profile.entry.credentials;
+  if (creds.type === "api-key") {
+    return creds.key;
+  }
+  if (creds.type === "oauth") {
+    return creds.access;
+  }
+  return void 0;
+};
+var readBody = (req) => new Promise((resolve, reject) => {
+  const chunks = [];
+  req.on("data", (chunk) => chunks.push(chunk));
+  req.on("end", () => resolve(Buffer.concat(chunks)));
+  req.on("error", reject);
+});
+var forwardRequest = async (method, path, headers, body, upstream) => {
+  const url = `${upstream}${path}`;
+  const reqHeaders = { ...headers };
+  delete reqHeaders["host"];
+  const response = await fetch(url, {
+    method,
+    headers: reqHeaders,
+    body: method !== "GET" && method !== "HEAD" ? body : void 0
+  });
+  const respHeaders = {};
+  response.headers.forEach((value, key) => {
+    respHeaders[key] = value;
+  });
+  if (respHeaders["content-type"]?.includes("text/event-stream") && response.body) {
+    return { status: response.status, headers: respHeaders, body: response.body };
+  }
+  const respBody = Buffer.from(await response.arrayBuffer());
+  return { status: response.status, headers: respHeaders, body: respBody };
+};
+var publishState = (stateWriter, profiles, activeId) => {
+  const targets = profiles.map((p) => ({
+    target_id: p.entry.id,
+    provider_id: p.entry.provider,
+    profile: p.entry.id,
+    state: p.consecutiveFailures > 0 ? "CoolingDown" : "Active",
+    health_score: Math.max(0, 1 - p.consecutiveFailures * 0.25),
+    latency_ema_ms: 0,
+    enabled: true
+  }));
+  const snapshot = {
+    version: 1,
+    updated_at: Date.now(),
+    active_target_id: activeId,
+    targets
+  };
+  stateWriter.write(snapshot);
+};
+var createProxy = async (userConfig = {}) => {
+  const config = { ...DEFAULT_CONFIG, ...userConfig };
+  const logger = createAuditLogger({ level: "info" });
+  const stateWriter = createStateWriter(300);
+  const store = await loadProfiles();
+  const providerProfiles = Object.values(store).filter(
+    (p) => p.provider === config.provider
+  );
+  if (providerProfiles.length === 0) {
+    throw new Error(
+      `No API key profiles found for provider "${config.provider}". Run o-switcher profile tools to add profiles first.`
+    );
+  }
+  const profiles = providerProfiles.map((entry) => ({
+    entry,
+    failedAt: null,
+    consecutiveFailures: 0
+  }));
+  logger.info(
+    { provider: config.provider, profiles: profiles.map((p) => p.entry.id), port: config.port },
+    "O-Switcher proxy initialized"
+  );
+  publishState(stateWriter, profiles, profiles[0]?.entry.id);
+  const handleRequest = async (req, res) => {
+    const method = req.method ?? "GET";
+    const path = req.url ?? "/";
+    if (path === "/health") {
+      res.writeHead(200, { "content-type": "application/json" });
+      res.end(JSON.stringify({ status: "ok", profiles: profiles.length }));
+      return;
+    }
+    const body = await readBody(req);
+    const pool = buildProfilePool(profiles);
+    if (pool.length === 0) {
+      res.writeHead(503, { "content-type": "application/json" });
+      res.end(JSON.stringify({ error: "All profiles exhausted" }));
+      return;
+    }
+    const maxAttempts = Math.min(config.maxRetries, pool.length);
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      const profile = pool[attempt];
+      const token = getBearerToken(profile);
+      if (!token) continue;
+      const headers = {};
+      for (const [key, value] of Object.entries(req.headers)) {
+        if (value && typeof value === "string") {
+          headers[key] = value;
+        }
+      }
+      headers["authorization"] = `Bearer ${token}`;
+      logger.info(
+        { profile: profile.entry.id, attempt: attempt + 1, path },
+        "Forwarding request"
+      );
+      try {
+        const result = await forwardRequest(method, path, headers, body, config.upstream);
+        if (result.status === 429) {
+          profile.consecutiveFailures += 1;
+          profile.failedAt = Date.now();
+          logger.warn(
+            { profile: profile.entry.id, attempt: attempt + 1, consecutiveFailures: profile.consecutiveFailures },
+            "Rate limited \u2014 trying next profile"
+          );
+          publishState(stateWriter, profiles, pool[attempt + 1]?.entry.id);
+          continue;
+        }
+        profile.consecutiveFailures = 0;
+        profile.failedAt = null;
+        publishState(stateWriter, profiles, profile.entry.id);
+        res.writeHead(result.status, result.headers);
+        if (result.body instanceof ReadableStream) {
+          const reader = result.body.getReader();
+          const pump = async () => {
+            const { done, value } = await reader.read();
+            if (done) {
+              res.end();
+              return;
+            }
+            res.write(value);
+            await pump();
+          };
+          await pump();
+        } else {
+          res.end(result.body);
+        }
+        return;
+      } catch (err) {
+        profile.consecutiveFailures += 1;
+        profile.failedAt = Date.now();
+        logger.error(
+          { profile: profile.entry.id, attempt: attempt + 1, err },
+          "Request failed \u2014 trying next profile"
+        );
+        publishState(stateWriter, profiles, pool[attempt + 1]?.entry.id);
+        continue;
+      }
+    }
+    res.writeHead(429, { "content-type": "application/json" });
+    res.end(JSON.stringify({
+      error: {
+        message: `All ${maxAttempts} profiles rate-limited. Try again later.`,
+        type: "rate_limit_error",
+        code: "all_profiles_exhausted"
+      }
+    }));
+  };
+  const start = () => new Promise((resolve) => {
+    const server = createServer((req, res) => {
+      handleRequest(req, res).catch((err) => {
+        logger.error({ err }, "Unhandled request error");
+        if (!res.headersSent) {
+          res.writeHead(500, { "content-type": "application/json" });
+        }
+        res.end(JSON.stringify({ error: "Internal proxy error" }));
+      });
+    });
+    server.listen(config.port, () => {
+      logger.info({ port: config.port, upstream: config.upstream }, "O-Switcher proxy listening");
+      resolve({
+        port: config.port,
+        close: () => {
+          server.close();
+          stateWriter.flush();
+        }
+      });
+    });
+  });
+  return { start };
+};
+
+export { createProxy, createStateWriter };