ampcode-connector 0.1.0

package/config.yaml

@@ -0,0 +1,20 @@
+# ampcode-connector configuration
+# ================================
+
+# Port the proxy server listens on
+port: 7860
+
+# Amp upstream URL (fallback for non-intercepted requests)
+# ampUpstreamUrl: https://ampcode.com
+
+# Amp API key (optional - also reads from AMP_API_KEY env or ~/.local/share/amp/secrets.json)
+# ampApiKey: your-amp-api-key
+
+# Log level: debug, info, warn, error
+logLevel: info
+
+# Enable/disable individual providers
+providers:
+  anthropic: true      # Claude Code OAuth -> api.anthropic.com
+  codex: true          # OpenAI Codex OAuth -> api.openai.com
+  google: true         # Google OAuth -> Gemini CLI + Antigravity dual quota

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "ampcode-connector",
+  "version": "0.1.0",
+  "description": "Proxy Amp CLI through local OAuth subscriptions (Claude Code, Codex, Gemini CLI, Antigravity)",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nghyane/ampcode-connector"
+  },
+  "keywords": [
+    "amp",
+    "ampcode",
+    "proxy",
+    "claude",
+    "openai",
+    "gemini",
+    "oauth"
+  ],
+  "module": "src/index.ts",
+  "type": "module",
+  "files": [
+    "src/**/*.ts",
+    "config.yaml",
+    "tsconfig.json"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "bin": {
+    "ampcode-connector": "src/index.ts"
+  },
+  "scripts": {
+    "start": "bun run src/index.ts",
+    "dev": "bun run --watch src/index.ts",
+    "setup": "bun run src/index.ts setup",
+    "login": "bun run src/index.ts login",
+    "test": "bun test",
+    "check": "biome check src/ tests/ && tsc --noEmit && bun test",
+    "format": "biome check --write src/ tests/"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.4.0",
+    "@types/bun": "latest"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  },
+  "dependencies": {
+    "@google/genai": "^1.41.0"
+  }
+}

package/src/auth/callback-server.ts

@@ -0,0 +1,92 @@
+/** Temporary localhost HTTP server to receive OAuth callbacks. */
+
+import { logger } from "../utils/logger.ts";
+
+export interface CallbackResult {
+  code: string;
+  state: string;
+}
+
+const DEFAULT_TIMEOUT = 120_000;
+
+export async function waitForCallback(
+  preferredPort: number,
+  callbackPath: string,
+  expectedState: string,
+  timeout: number = DEFAULT_TIMEOUT,
+): Promise<CallbackResult> {
+  return new Promise((resolve, reject) => {
+    let server: ReturnType<typeof Bun.serve> | null = null;
+    let timeoutId: ReturnType<typeof setTimeout> | null = null;
+
+    const cleanup = () => {
+      if (timeoutId) clearTimeout(timeoutId);
+      if (server) {
+        server.stop(true);
+        server = null;
+      }
+    };
+
+    timeoutId = setTimeout(() => {
+      cleanup();
+      reject(new Error(`OAuth callback timed out after ${timeout}ms`));
+    }, timeout);
+
+    try {
+      server = Bun.serve({
+        port: preferredPort,
+        hostname: "localhost",
+        fetch(req) {
+          const url = new URL(req.url);
+          if (url.pathname !== callbackPath) return new Response("Not found", { status: 404 });
+
+          const code = url.searchParams.get("code");
+          const state = url.searchParams.get("state");
+          const error = url.searchParams.get("error");
+          const errorDescription = url.searchParams.get("error_description");
+
+          if (error) {
+            cleanup();
+            reject(new Error(`OAuth error: ${error} - ${errorDescription ?? "unknown"}`));
+            return htmlPage("Authentication Failed", `Error: ${error}. ${errorDescription ?? ""}`);
+          }
+
+          if (!code || !state) {
+            cleanup();
+            reject(new Error("Missing code or state in OAuth callback"));
+            return htmlPage("Authentication Failed", "Missing authorization code.");
+          }
+
+          if (state !== expectedState) {
+            cleanup();
+            reject(new Error("State mismatch in OAuth callback (possible CSRF)"));
+            return htmlPage("Authentication Failed", "State validation failed.");
+          }
+
+          cleanup();
+          resolve({ code, state });
+          return htmlPage("Authentication Successful", "You can close this window and return to the terminal.");
+        },
+      });
+
+      logger.debug("Callback server started", { provider: `port:${preferredPort}` });
+    } catch (err) {
+      cleanup();
+      reject(new Error(`Failed to start callback server on port ${preferredPort}: ${err}`));
+    }
+  });
+}
+
+function htmlPage(title: string, message: string): Response {
+  const body = `<!DOCTYPE html>
+<html>
+<head><title>${title}</title></head>
+<body style="font-family: system-ui; display: flex; justify-content: center; align-items: center; height: 100vh; margin: 0;">
+  <div style="text-align: center;">
+    <h1>${title}</h1>
+    <p>${message}</p>
+  </div>
+</body>
+</html>`;
+  return new Response(body, { headers: { "Content-Type": "text/html" } });
+}

package/src/auth/configs.ts

@@ -0,0 +1,57 @@
+import { ANTHROPIC_TOKEN_URL, GOOGLE_TOKEN_URL, OPENAI_TOKEN_URL } from "../constants.ts";
+import { discoverAnthropic, discoverCodex, discoverGoogle } from "./discovery.ts";
+import type { OAuthConfig } from "./oauth.ts";
+
+export const anthropic: OAuthConfig = {
+  providerName: "anthropic",
+  clientId: "9d1c250a-e61b-44d9-88ed-5944d1962f5e",
+  authorizeUrl: "https://claude.ai/oauth/authorize",
+  tokenUrl: ANTHROPIC_TOKEN_URL,
+  callbackPort: 54545,
+  callbackPath: "/callback",
+  scopes: "org:create_api_key user:profile user:inference user:sessions:claude_code user:mcp_servers",
+  bodyFormat: "json",
+  expiryBuffer: true,
+  sendStateInExchange: true,
+  authorizeExtra: { code: "true" },
+  extractIdentity: discoverAnthropic,
+};
+
+export const codex: OAuthConfig = {
+  providerName: "codex",
+  clientId: "app_EMoamEEZ73f0CkXaXp7hrann",
+  authorizeUrl: "https://auth.openai.com/oauth/authorize",
+  tokenUrl: OPENAI_TOKEN_URL,
+  callbackPort: 1455,
+  callbackPath: "/auth/callback",
+  scopes: "openid profile email offline_access",
+  bodyFormat: "form",
+  expiryBuffer: true,
+  authorizeExtra: {
+    id_token_add_organizations: "true",
+    codex_cli_simplified_flow: "true",
+    originator: "opencode",
+  },
+  extractIdentity: discoverCodex,
+};
+
+export const google: OAuthConfig = {
+  providerName: "google",
+  clientId: "1071006060591-tmhssin2h21lcre235vtolojh4g403ep.apps.googleusercontent.com",
+  clientSecret: "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",
+  authorizeUrl: "https://accounts.google.com/o/oauth2/v2/auth",
+  tokenUrl: GOOGLE_TOKEN_URL,
+  callbackPort: 51121,
+  callbackPath: "/oauth-callback",
+  scopes: [
+    "https://www.googleapis.com/auth/cloud-platform",
+    "https://www.googleapis.com/auth/userinfo.email",
+    "https://www.googleapis.com/auth/userinfo.profile",
+    "https://www.googleapis.com/auth/cclog",
+    "https://www.googleapis.com/auth/experimentsandconfigs",
+  ].join(" "),
+  bodyFormat: "form",
+  expiryBuffer: true,
+  authorizeExtra: { access_type: "offline", prompt: "consent" },
+  extractIdentity: discoverGoogle,
+};

package/src/auth/discovery.ts

@@ -0,0 +1,100 @@
+import {
+  ANTIGRAVITY_DAILY_ENDPOINT,
+  AUTOPUSH_ENDPOINT,
+  CODE_ASSIST_ENDPOINT,
+  DEFAULT_ANTIGRAVITY_PROJECT,
+} from "../constants.ts";
+import { fromBase64url } from "../utils/encoding.ts";
+import { logger } from "../utils/logger.ts";
+import type { Credentials } from "./store.ts";
+
+type Raw = Record<string, unknown>;
+
+export async function discoverAnthropic(raw: Raw): Promise<Partial<Credentials>> {
+  const account = raw.account as { uuid?: string; email_address?: string } | undefined;
+  return {
+    ...(account?.email_address ? { email: account.email_address } : {}),
+    ...(account?.uuid ? { accountId: account.uuid } : {}),
+  };
+}
+
+export async function discoverCodex(raw: Raw): Promise<Partial<Credentials>> {
+  const accessToken = raw.access_token as string;
+  const accountId = accountIdFromJWT(accessToken);
+  const email = await fetchEmail("https://api.openai.com/v1/me", accessToken);
+  return {
+    ...(accountId ? { accountId } : {}),
+    ...(email ? { email } : {}),
+  };
+}
+
+export async function discoverGoogle(raw: Raw): Promise<Partial<Credentials>> {
+  const accessToken = raw.access_token as string;
+  const email = await fetchEmail("https://www.googleapis.com/oauth2/v1/userinfo?alt=json", accessToken);
+  const projectId = await findProject(accessToken);
+  return { ...(email ? { email } : {}), ...(projectId ? { projectId } : {}) };
+}
+
+function accountIdFromJWT(token: string): string | null {
+  try {
+    const parts = token.split(".");
+    if (parts.length < 2 || !parts[1]) return null;
+    const payload = JSON.parse(new TextDecoder().decode(fromBase64url(parts[1]))) as Raw;
+    const auth = payload["https://api.openai.com/auth"] as Raw | undefined;
+    return (auth?.["chatgpt_account_id"] as string) ?? null;
+  } catch {
+    return null;
+  }
+}
+
+async function fetchEmail(url: string, accessToken: string): Promise<string | undefined> {
+  try {
+    const res = await fetch(url, { headers: { Authorization: `Bearer ${accessToken}` } });
+    if (!res.ok) return undefined;
+    return ((await res.json()) as { email?: string }).email;
+  } catch {
+    return undefined;
+  }
+}
+
+const CCA_HEADERS = {
+  "Content-Type": "application/json",
+  "User-Agent": "google-api-nodejs-client/9.15.1",
+  "X-Goog-Api-Client": "google-cloud-sdk vscode_cloudshelleditor/0.1",
+  "Client-Metadata": JSON.stringify({
+    ideType: "IDE_UNSPECIFIED",
+    platform: "PLATFORM_UNSPECIFIED",
+    pluginType: "GEMINI",
+  }),
+} as const;
+
+const CCA_BODY = JSON.stringify({
+  metadata: { ideType: "IDE_UNSPECIFIED", platform: "PLATFORM_UNSPECIFIED", pluginType: "GEMINI" },
+});
+
+async function findProject(accessToken: string): Promise<string | undefined> {
+  for (const endpoint of [CODE_ASSIST_ENDPOINT, ANTIGRAVITY_DAILY_ENDPOINT, AUTOPUSH_ENDPOINT]) {
+    try {
+      const res = await fetch(`${endpoint}/v1internal:loadCodeAssist`, {
+        method: "POST",
+        headers: { ...CCA_HEADERS, Authorization: `Bearer ${accessToken}` },
+        body: CCA_BODY,
+      });
+
+      if (!res.ok) {
+        logger.debug(`loadCodeAssist ${res.status} at ${endpoint}`);
+        continue;
+      }
+
+      const body = (await res.json()) as { cloudaicompanionProject?: string | { id?: string } };
+      const proj = body.cloudaicompanionProject;
+      const id = typeof proj === "string" ? proj : proj?.id;
+      if (id) return id;
+    } catch (err) {
+      logger.debug(`loadCodeAssist error at ${endpoint}`, { error: String(err) });
+    }
+  }
+
+  logger.warn(`Project discovery failed, using fallback: ${DEFAULT_ANTIGRAVITY_PROJECT}`);
+  return DEFAULT_ANTIGRAVITY_PROJECT;
+}

package/src/auth/oauth.ts

@@ -0,0 +1,183 @@
+import { TOKEN_EXPIRY_BUFFER_MS } from "../constants.ts";
+import * as browser from "../utils/browser.ts";
+import { logger } from "../utils/logger.ts";
+import { waitForCallback } from "./callback-server.ts";
+import { generatePKCE, generateState } from "./pkce.ts";
+import type { Credentials, ProviderName } from "./store.ts";
+import * as store from "./store.ts";
+
+export interface OAuthConfig {
+  providerName: ProviderName;
+  clientId: string;
+  clientSecret?: string;
+  authorizeUrl: string;
+  tokenUrl: string;
+  callbackPort: number;
+  callbackPath: string;
+  scopes: string;
+  bodyFormat: "json" | "form";
+  authorizeExtra?: Record<string, string>;
+  expiryBuffer?: boolean;
+  sendStateInExchange?: boolean;
+  extractIdentity?: (raw: Record<string, unknown>) => Promise<Partial<Credentials>>;
+}
+
+export async function token(config: OAuthConfig, account = 0): Promise<string | null> {
+  const creds = store.get(config.providerName, account);
+
+  if (!creds) {
+    try {
+      return (await serialize(config)).accessToken;
+    } catch (err) {
+      logger.error(`Auto-login failed for ${config.providerName}`, { error: String(err) });
+      return null;
+    }
+  }
+
+  if (store.fresh(creds)) return creds.accessToken;
+
+  try {
+    return (await refresh(config, creds.refreshToken, account)).accessToken;
+  } catch (err) {
+    logger.error(`Token refresh failed for ${config.providerName}:${account}`, { error: String(err) });
+    return null;
+  }
+}
+
+export async function tokenFromAny(config: OAuthConfig): Promise<{ accessToken: string; account: number } | null> {
+  for (const { account, credentials: c } of store.getAll(config.providerName)) {
+    if (store.fresh(c)) return { accessToken: c.accessToken, account };
+  }
+
+  for (const { account, credentials: c } of store.getAll(config.providerName)) {
+    if (!c.refreshToken) continue;
+    try {
+      const refreshed = await refresh(config, c.refreshToken, account);
+      return { accessToken: refreshed.accessToken, account };
+    } catch {
+      continue;
+    }
+  }
+
+  return null;
+}
+
+export function ready(config: OAuthConfig): boolean {
+  return store.exists(config.providerName);
+}
+
+export function accountCount(config: OAuthConfig): number {
+  return store.count(config.providerName);
+}
+
+export async function login(config: OAuthConfig): Promise<Credentials> {
+  const { verifier, challenge } = await generatePKCE();
+  const state = generateState();
+  const redirectUri = `http://localhost:${config.callbackPort}${config.callbackPath}`;
+
+  const authUrl = new URL(config.authorizeUrl);
+  const q = authUrl.searchParams;
+  q.set("client_id", config.clientId);
+  q.set("response_type", "code");
+  q.set("redirect_uri", redirectUri);
+  q.set("scope", config.scopes);
+  q.set("code_challenge", challenge);
+  q.set("code_challenge_method", "S256");
+  q.set("state", state);
+  if (config.authorizeExtra) {
+    for (const [k, v] of Object.entries(config.authorizeExtra)) q.set(k, v);
+  }
+
+  logger.info(`Opening browser for ${config.providerName} OAuth...`);
+  if (!(await browser.open(authUrl.toString()))) {
+    logger.warn("Could not open browser. Please open this URL manually:");
+    logger.info(authUrl.toString());
+  }
+
+  const callback = await waitForCallback(config.callbackPort, config.callbackPath, state);
+
+  const exchangeParams: Record<string, string> = {
+    grant_type: "authorization_code",
+    code: callback.code,
+    redirect_uri: redirectUri,
+    code_verifier: verifier,
+  };
+  if (config.sendStateInExchange) exchangeParams["state"] = callback.state;
+
+  const raw = await exchange(config, exchangeParams);
+  let credentials = parseTokenFields(raw, config);
+
+  if (config.extractIdentity) {
+    try {
+      credentials = { ...credentials, ...(await config.extractIdentity(raw)) };
+    } catch (err) {
+      logger.error(`${config.providerName} identity extraction failed`, { error: String(err) });
+    }
+  }
+
+  const existing = store.findByIdentity(config.providerName, credentials);
+  const account = existing ?? store.nextAccount(config.providerName);
+
+  if (!credentials.refreshToken) {
+    credentials.refreshToken = store.get(config.providerName, account)?.refreshToken ?? "";
+  }
+  if (!credentials.refreshToken) {
+    throw new Error(`No refresh token for ${config.providerName}. Revoke app access and try again.`);
+  }
+
+  store.save(config.providerName, credentials, account);
+  logger.info(`${config.providerName}:${account} ${existing !== null ? "updated" : "added"}`);
+  return credentials;
+}
+
+const loginLocks = new Map<ProviderName, Promise<Credentials>>();
+
+function serialize(config: OAuthConfig): Promise<Credentials> {
+  const pending = loginLocks.get(config.providerName);
+  if (pending) return pending;
+
+  const promise = login(config).finally(() => loginLocks.delete(config.providerName));
+  loginLocks.set(config.providerName, promise);
+  return promise;
+}
+
+async function refresh(config: OAuthConfig, refreshToken: string, account = 0): Promise<Credentials> {
+  const raw = await exchange(config, { grant_type: "refresh_token", refresh_token: refreshToken });
+
+  const credentials: Credentials = {
+    ...store.get(config.providerName, account),
+    ...parseTokenFields(raw, config),
+    refreshToken: (raw.refresh_token as string) ?? refreshToken,
+  };
+
+  store.save(config.providerName, credentials, account);
+  return credentials;
+}
+
+async function exchange(config: OAuthConfig, params: Record<string, string>): Promise<Record<string, unknown>> {
+  const all: Record<string, string> = { client_id: config.clientId, ...params };
+  if (config.clientSecret) all["client_secret"] = config.clientSecret;
+
+  const isJson = config.bodyFormat === "json";
+  const res = await fetch(config.tokenUrl, {
+    method: "POST",
+    headers: { "Content-Type": isJson ? "application/json" : "application/x-www-form-urlencoded" },
+    body: isJson ? JSON.stringify(all) : new URLSearchParams(all).toString(),
+  });
+
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`${config.providerName} token exchange failed (${res.status}): ${text}`);
+  }
+
+  return (await res.json()) as Record<string, unknown>;
+}
+
+function parseTokenFields(raw: Record<string, unknown>, config: OAuthConfig): Credentials {
+  const buffer = config.expiryBuffer !== false ? TOKEN_EXPIRY_BUFFER_MS : 0;
+  return {
+    accessToken: raw.access_token as string,
+    refreshToken: (raw.refresh_token as string) ?? "",
+    expiresAt: Date.now() + (raw.expires_in as number) * 1000 - buffer,
+  };
+}

package/src/auth/pkce.ts

@@ -0,0 +1,22 @@
+/** PKCE (Proof Key for Code Exchange) — S256 challenge for all OAuth flows. */
+
+import { toBase64url } from "../utils/encoding.ts";
+
+export async function generatePKCE(): Promise<{ verifier: string; challenge: string }> {
+  const verifierBytes = new Uint8Array(96);
+  crypto.getRandomValues(verifierBytes);
+  const verifier = toBase64url(verifierBytes);
+
+  const hashBuffer = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(verifier));
+  const challenge = toBase64url(new Uint8Array(hashBuffer));
+
+  return { verifier, challenge };
+}
+
+export function generateState(): string {
+  const bytes = new Uint8Array(16);
+  crypto.getRandomValues(bytes);
+  return Array.from(bytes)
+    .map((b) => b.toString(16).padStart(2, "0"))
+    .join("");
+}

package/src/auth/store.ts

@@ -0,0 +1,105 @@
+/** SQLite credential storage at ~/.ampcode-connector/credentials.db
+ *  Multi-account: composite key (provider, account).
+ *  Sync API via bun:sqlite — no cache needed at 0.4µs/read. */
+
+import { Database } from "bun:sqlite";
+import { mkdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+export interface Credentials {
+  accessToken: string;
+  refreshToken: string;
+  expiresAt: number;
+  projectId?: string;
+  email?: string;
+  accountId?: string;
+}
+
+export type ProviderName = "anthropic" | "codex" | "google";
+
+const DIR = join(homedir(), ".ampcode-connector");
+const DB_PATH = join(DIR, "credentials.db");
+
+mkdirSync(DIR, { recursive: true, mode: 0o700 });
+
+const db = new Database(DB_PATH, { strict: true });
+db.exec("PRAGMA journal_mode=WAL");
+
+db.exec(`
+  CREATE TABLE IF NOT EXISTS credentials (
+    provider TEXT NOT NULL,
+    account  INTEGER NOT NULL DEFAULT 0,
+    data     TEXT NOT NULL,
+    PRIMARY KEY (provider, account)
+  )
+`);
+
+const stmtGet = db.prepare<{ data: string }, [string, number]>(
+  "SELECT data FROM credentials WHERE provider = ? AND account = ?",
+);
+const stmtGetAll = db.prepare<{ account: number; data: string }, [string]>(
+  "SELECT account, data FROM credentials WHERE provider = ? ORDER BY account",
+);
+const stmtSet = db.prepare<void, [string, number, string]>(
+  "INSERT OR REPLACE INTO credentials (provider, account, data) VALUES (?, ?, ?)",
+);
+const stmtDelOne = db.prepare<void, [string, number]>("DELETE FROM credentials WHERE provider = ? AND account = ?");
+const stmtDelAll = db.prepare<void, [string]>("DELETE FROM credentials WHERE provider = ?");
+const stmtMaxAccount = db.prepare<{ max_account: number | null }, [string]>(
+  "SELECT MAX(account) as max_account FROM credentials WHERE provider = ?",
+);
+const stmtCount = db.prepare<{ cnt: number }, [string]>("SELECT COUNT(*) as cnt FROM credentials WHERE provider = ?");
+
+export function get(provider: ProviderName, account = 0): Credentials | undefined {
+  const row = stmtGet.get(provider, account);
+  if (!row) return undefined;
+  return JSON.parse(row.data) as Credentials;
+}
+
+export function getAll(provider: ProviderName): { account: number; credentials: Credentials }[] {
+  return stmtGetAll.all(provider).map((row) => ({
+    account: row.account,
+    credentials: JSON.parse(row.data) as Credentials,
+  }));
+}
+
+export function save(provider: ProviderName, credentials: Credentials, account = 0): void {
+  stmtSet.run(provider, account, JSON.stringify(credentials));
+}
+
+export function remove(provider: ProviderName, account?: number): void {
+  if (account !== undefined) {
+    stmtDelOne.run(provider, account);
+  } else {
+    stmtDelAll.run(provider);
+  }
+}
+
+export function nextAccount(provider: ProviderName): number {
+  const row = stmtMaxAccount.get(provider);
+  return (row?.max_account ?? -1) + 1;
+}
+
+export function count(provider: ProviderName): number {
+  return stmtCount.get(provider)?.cnt ?? 0;
+}
+
+/** Find existing account by email or accountId match. */
+export function findByIdentity(provider: ProviderName, credentials: Credentials): number | null {
+  const all = getAll(provider);
+  for (const entry of all) {
+    if (credentials.email && entry.credentials.email === credentials.email) return entry.account;
+    if (credentials.accountId && entry.credentials.accountId === credentials.accountId) return entry.account;
+  }
+  return null;
+}
+
+export function exists(provider: ProviderName): boolean {
+  const all = getAll(provider);
+  return all.some((e) => !!e.credentials.refreshToken);
+}
+
+export function fresh(credentials: Credentials): boolean {
+  return Date.now() < credentials.expiresAt;
+}

package/src/cli/ansi.ts

@@ -0,0 +1,37 @@
+/** Raw ANSI escape helpers — no dependencies. */
+
+const ESC = "\x1b[";
+
+export const cursor = {
+  hide: () => out(`${ESC}?25l`),
+  show: () => out(`${ESC}?25h`),
+  home: () => out(`${ESC}H`),
+};
+
+export const screen = {
+  clear: () => out(`${ESC}2J${ESC}H`),
+};
+
+/** Erase from cursor to end of line. */
+export const eol = `${ESC}K`;
+
+export const s = {
+  reset: `${ESC}0m`,
+  bold: `${ESC}1m`,
+  dim: `${ESC}2m`,
+  inverse: `${ESC}7m`,
+  green: `${ESC}32m`,
+  red: `${ESC}31m`,
+  yellow: `${ESC}33m`,
+  gray: `${ESC}90m`,
+  cyan: `${ESC}36m`,
+  white: `${ESC}37m`,
+};
+
+export function out(text: string): void {
+  process.stdout.write(text);
+}
+
+export function line(text = ""): void {
+  process.stdout.write(`${text}${eol}\n`);
+}