offrouter-cli 0.2.1 → 0.3.0

package/src/commands/login.test.ts

@@ -1,247 +0,0 @@
-/**
- * Tests for the `offrouter login` command.
- *
- * Mocks `offrouter-core` functions so the login command runs without real OAuth.
- * FileSecretStore is NOT mocked; it runs against a real temp directory.
- */
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { mkdtempSync, rmSync, existsSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-// ---------------------------------------------------------------------------
-// Mock offrouter-core for login tests
-// ---------------------------------------------------------------------------
-const mocks = vi.hoisted(() => ({
-  mockRunOAuthLogin: vi.fn(),
-  mockGetOAuthTokens: vi.fn(),
-  mockIsOAuthTokenExpired: vi.fn(),
-  mockRefreshTokens: vi.fn(),
-  mockResolveClientId: vi.fn(),
-  mockResolveOffRouterHome: vi.fn(),
-}));
-
-// Keep FileSecretStore real but mock the core functions.
-vi.mock("offrouter-core", async () => {
-  const actual = await vi.importActual<typeof import("offrouter-core")>("offrouter-core");
-  return {
-    ...actual,
-    runOAuthLogin: mocks.mockRunOAuthLogin,
-    getOAuthTokens: mocks.mockGetOAuthTokens,
-    isOAuthTokenExpired: mocks.mockIsOAuthTokenExpired,
-    refreshTokens: mocks.mockRefreshTokens,
-    resolveClientId: mocks.mockResolveClientId,
-    resolveOffRouterHome: mocks.mockResolveOffRouterHome,
-  };
-});
-
-import { createProgram } from "../index.js";
-
-function capture(
-  argv: string[],
-  env: NodeJS.ProcessEnv = { ...process.env },
-): Promise<{ code: number; stdout: string; stderr: string }> {
-  return new Promise((resolve) => {
-    let stdout = "";
-    let stderr = "";
-    const program = createProgram({
-      env,
-      stdout: {
-        write(chunk: string) {
-          stdout += chunk;
-          return true;
-        },
-      },
-      stderr: {
-        write(chunk: string) {
-          stderr += chunk;
-          return true;
-        },
-      },
-    });
-
-    program
-      .parseAsync(argv, { from: "user" })
-      .then(() => {
-        resolve({ code: 0, stdout, stderr });
-      })
-      .catch((err) => {
-        const code = err?.exitCode ?? 1;
-        resolve({ code, stdout, stderr });
-      });
-  });
-}
-
-describe("offrouter login command", () => {
-  let tmpHome: string;
-
-  beforeEach(() => {
-    vi.resetAllMocks();
-    tmpHome = mkdtempSync(join(tmpdir(), "offrouter-login-test-"));
-    mocks.mockResolveOffRouterHome.mockReturnValue(tmpHome);
-  });
-
-  afterEach(() => {
-    if (tmpHome && existsSync(tmpHome)) {
-      rmSync(tmpHome, { recursive: true, force: true });
-    }
-  });
-
-  describe("help", () => {
-    it("offrouter login --help shows login command", async () => {
-      const { code, stdout, stderr } = await capture(["login", "--help"]);
-      expect(code).toBe(0);
-      const output = stdout + stderr;
-      expect(output).toMatch(/login/i);
-      expect(output).toMatch(/provider/i);
-      expect(output).toMatch(/anthropic/i);
-      expect(output).toMatch(/openai/i);
-    });
-  });
-
-  describe("login <provider>", () => {
-    it("calls runOAuthLogin with the provider and stores tokens", async () => {
-      mocks.mockResolveClientId.mockReturnValue("test-client-id");
-      mocks.mockRunOAuthLogin.mockResolvedValue({
-        provider: "anthropic",
-        redirectUri: "http://127.0.0.1:1456/callback",
-        expiresAt: Date.now() + 3600_000,
-        scope: "api offline_access",
-      });
-
-      const { code, stdout, stderr } = await capture(
-        ["login", "anthropic"],
-        {
-          ...process.env,
-          OFFROUTER_HOME: tmpHome,
-        },
-      );
-
-      expect(code).toBe(0);
-      expect(stderr).toBe("");
-
-      expect(mocks.mockRunOAuthLogin).toHaveBeenCalledWith(
-        expect.objectContaining({
-          provider: "anthropic",
-          clientId: "test-client-id",
-        }),
-      );
-
-      expect(stdout).toMatch(/successful|Login/);
-      expect(stdout).toContain("anthropic");
-    });
-
-    it("prints error for unsupported provider", async () => {
-      const { code, stdout } = await capture(["login", "gemini"]);
-      expect(code).toBe(0);
-      expect(stdout).toMatch(/not supported/i);
-      expect(mocks.mockRunOAuthLogin).not.toHaveBeenCalled();
-    });
-
-    it("prints error when no client id is configured", async () => {
-      const { code, stdout } = await capture(
-        ["login", "anthropic"],
-        { ...process.env, OFFROUTER_HOME: tmpHome },
-      );
-      expect(code).toBe(0);
-      expect(stdout).toMatch(/client id required|client.*id/i);
-      expect(mocks.mockRunOAuthLogin).not.toHaveBeenCalled();
-    });
-  });
-
-  describe("login --list", () => {
-    it("shows providers with no tokens when none stored", async () => {
-      mocks.mockGetOAuthTokens.mockResolvedValue(undefined);
-
-      const { code, stdout } = await capture(
-        ["login", "--list"],
-        { ...process.env, OFFROUTER_HOME: tmpHome },
-      );
-      expect(code).toBe(0);
-      expect(stdout).toMatch(/OAuth providers/i);
-      expect(stdout).toContain("anthropic");
-      expect(stdout).toContain("openai");
-    });
-
-    it("shows active token status", async () => {
-      mocks.mockGetOAuthTokens.mockResolvedValue({
-        accessToken: "tok",
-        refreshToken: "refresh",
-        expiresAt: Date.now() + 3600_000,
-        obtainedAt: Date.now(),
-      });
-      mocks.mockIsOAuthTokenExpired.mockReturnValue(false);
-
-      const { code, stdout } = await capture(
-        ["login", "--list"],
-        { ...process.env, OFFROUTER_HOME: tmpHome },
-      );
-      expect(code).toBe(0);
-      expect(stdout).toContain("active");
-    });
-
-    it("shows expired token status", async () => {
-      mocks.mockGetOAuthTokens.mockResolvedValue({
-        accessToken: "tok",
-        refreshToken: "refresh",
-        expiresAt: Date.now() - 1000,
-        obtainedAt: Date.now() - 7200_000,
-      });
-      mocks.mockIsOAuthTokenExpired.mockReturnValue(true);
-
-      const { code, stdout } = await capture(
-        ["login", "--list"],
-        { ...process.env, OFFROUTER_HOME: tmpHome },
-      );
-      expect(code).toBe(0);
-      expect(stdout).toContain("expired");
-    });
-  });
-
-  describe("login --status <provider>", () => {
-    it("shows status for unsupported provider", async () => {
-      const { code, stdout } = await capture(
-        ["login", "--status", "gemini"],
-      );
-      expect(code).toBe(0);
-      expect(stdout).toMatch(/not supported/i);
-    });
-  });
-
-  describe("login --json", () => {
-    it("returns JSON for successful login", async () => {
-      mocks.mockResolveClientId.mockReturnValue("test-oa-id");
-      mocks.mockRunOAuthLogin.mockResolvedValue({
-        provider: "openai",
-        redirectUri: "http://127.0.0.1:1455/callback",
-        expiresAt: 9999999999000,
-        scope: "offline_access",
-      });
-
-      const { code, stdout } = await capture(
-        ["login", "openai", "--json"],
-        {
-          ...process.env,
-          OFFROUTER_HOME: tmpHome,
-        },
-      );
-
-      expect(code).toBe(0);
-      const json = JSON.parse(stdout) as Record<string, unknown>;
-      expect(json.ok).toBe(true);
-      expect(json.provider).toBe("openai");
-      expect(json.redirectUri).toContain("127.0.0.1");
-    });
-
-    it("returns JSON error for unsupported provider", async () => {
-      const { code, stdout } = await capture(
-        ["login", "gemini", "--json"],
-        { ...process.env, OFFROUTER_HOME: tmpHome },
-      );
-
-      expect(code).toBe(0);
-      const json = JSON.parse(stdout) as Record<string, unknown>;
-      expect(json.error).toMatch(/not supported/i);
-    });
-  });
-});

package/src/commands/login.ts

@@ -1,413 +0,0 @@
-/**
- * `offrouter login` command: real OAuth PKCE login with browser open.
- *
- * Supports anthropic and openai (bring-your-own-client-id, documented as fragile).
- * Tokens are stored in the OffRouter secret store (keychain or file fallback).
- * Never scrapes or copies credentials from other CLIs.
- */
-import type { Command } from "commander";
-import { execSync } from "node:child_process";
-import { join } from "node:path";
-import {
-  FileSecretStore,
-  PKCE_CONFIGS,
-  getOAuthTokens,
-  isOAuthProvider,
-  isOAuthTokenExpired,
-  refreshTokens,
-  resolveClientId,
-  resolveOffRouterHome,
-  runOAuthLogin,
-} from "offrouter-core";
-import type { OAuthStoredTokens } from "offrouter-core";
-import { writeJson, writeText } from "./output.js";
-import type { CommandContext } from "./init.js";
-
-// ---------------------------------------------------------------------------
-// Browser open (macOS, best-effort)
-// ---------------------------------------------------------------------------
-
-function openBrowser(url: string): boolean {
-  try {
-    execSync(`open "${url}"`, { timeout: 5000, stdio: "ignore" });
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Secret store helpers
-// ---------------------------------------------------------------------------
-
-function createStore(env: NodeJS.ProcessEnv): FileSecretStore {
-  const home = resolveOffRouterHome({ env });
-  return new FileSecretStore({ filePath: join(home, "secrets.json") });
-}
-
-// ---------------------------------------------------------------------------
-// Provider display helpers
-// ---------------------------------------------------------------------------
-
-interface OAuthProviderInfo {
-  id: string;
-  clientId: string | null;
-  tokensStored: boolean;
-  hasRefreshToken: boolean;
-  expired: boolean | null;
-}
-
-async function listOAuthProviders(
-  env: NodeJS.ProcessEnv,
-): Promise<OAuthProviderInfo[]> {
-  const providers = Object.keys(PKCE_CONFIGS);
-  const store = createStore(env);
-  const results: OAuthProviderInfo[] = [];
-
-  for (const id of providers) {
-    const clientId = resolveClientId(id, env) ?? null;
-    let tokens: OAuthStoredTokens | undefined;
-    try {
-      tokens = await getOAuthTokens(id, store);
-    } catch {
-      tokens = undefined;
-    }
-
-    results.push({
-      id,
-      clientId,
-      tokensStored: !!tokens,
-      hasRefreshToken: !!tokens?.refreshToken,
-      expired: tokens ? isOAuthTokenExpired(tokens) : null,
-    });
-  }
-
-  return results;
-}
-
-async function statusForProvider(
-  providerId: string,
-  env: NodeJS.ProcessEnv,
-): Promise<{
-  provider: string;
-  valid: boolean;
-  expired: boolean;
-  hasRefreshToken: boolean;
-  refreshed: boolean;
-  error?: string;
-}> {
-  const store = createStore(env);
-  const tokens = await getOAuthTokens(providerId, store);
-
-  if (!tokens) {
-    return {
-      provider: providerId,
-      valid: false,
-      expired: false,
-      hasRefreshToken: false,
-      refreshed: false,
-      error: "No OAuth tokens stored. Run `offrouter login <provider>` first.",
-    };
-  }
-
-  const expired = isOAuthTokenExpired(tokens);
-
-  if (!expired) {
-    return {
-      provider: providerId,
-      valid: true,
-      expired: false,
-      hasRefreshToken: !!tokens.refreshToken,
-      refreshed: false,
-    };
-  }
-
-  // Expired: try refresh if we have a refresh token.
-  if (!tokens.refreshToken) {
-    return {
-      provider: providerId,
-      valid: false,
-      expired: true,
-      hasRefreshToken: false,
-      refreshed: false,
-      error:
-        "Token is expired and no refresh token is available. Run `offrouter login` again.",
-    };
-  }
-
-  try {
-    await refreshTokens(providerId, tokens.refreshToken, store);
-    return {
-      provider: providerId,
-      valid: true,
-      expired: false,
-      hasRefreshToken: true,
-      refreshed: true,
-    };
-  } catch (err) {
-    return {
-      provider: providerId,
-      valid: false,
-      expired: true,
-      hasRefreshToken: true,
-      refreshed: false,
-      error: err instanceof Error ? err.message : "Token refresh failed",
-    };
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Command registration
-// ---------------------------------------------------------------------------
-
-export function registerLoginCommand(
-  program: Command,
-  ctx: () => CommandContext,
-): void {
-  const cmd = program
-    .command("login")
-    .description(
-      "Authenticate with an OAuth provider (Anthropic or OpenAI). Tokens stored in the OffRouter secret store.",
-    )
-    .argument("[provider]", "Provider id (anthropic, openai)")
-    .option("--list", "List providers with stored tokens")
-    .option("--status <provider>", "Check token status for a provider")
-    .option("--json", "Emit JSON", false)
-    .option("--timeout <ms>", "OAuth callback timeout in milliseconds")
-    .option(
-      "--client-id <id>",
-      "Override client ID (default from OFFROUTER_*_CLIENT_ID env)",
-    );
-
-  cmd.action(
-    async (
-      provider: string | undefined,
-      opts: {
-        json?: boolean;
-        list?: boolean;
-        status?: string;
-        timeout?: string;
-        clientId?: string;
-      },
-    ) => {
-      const { env, stdout } = ctx();
-
-      // --list
-      if (opts.list) {
-        await handleList(stdout, env, !!opts.json);
-        return;
-      }
-
-      // --status <provider>
-      if (opts.status) {
-        await handleStatus(stdout, env, opts.status, !!opts.json);
-        return;
-      }
-
-      // login <provider> (full flow)
-      if (!provider) {
-        if (opts.json) {
-          writeJson(stdout, {
-            error: "Missing provider argument. Run `offrouter login --help` for usage.",
-          });
-        } else {
-          writeText(
-            stdout,
-            "Missing provider. Usage: offrouter login <provider> [options]",
-          );
-        }
-        return;
-      }
-
-      await handleLogin(stdout, env, provider, opts);
-    },
-  );
-}
-
-// ---------------------------------------------------------------------------
-// Handlers
-// ---------------------------------------------------------------------------
-
-async function handleList(
-  stdout: { write(chunk: string): boolean | void },
-  env: NodeJS.ProcessEnv,
-  json: boolean,
-): Promise<void> {
-  const providers = await listOAuthProviders(env);
-
-  if (json) {
-    writeJson(stdout, { providers });
-    return;
-  }
-
-  if (providers.length === 0) {
-    writeText(stdout, "No OAuth providers configured.");
-    return;
-  }
-
-  writeText(stdout, "OAuth providers:");
-  for (const p of providers) {
-    const tokenStatus = p.tokensStored
-      ? p.expired
-        ? "expired"
-        : "active"
-      : "no tokens";
-    const refreshStatus = p.hasRefreshToken ? " (refresh token)" : "";
-    const clientStatus = p.clientId ? `client-id: ${p.clientId}` : "no client-id configured";
-    writeText(stdout, `  ${p.id}: ${tokenStatus}${refreshStatus}, ${clientStatus}`);
-  }
-}
-
-async function handleStatus(
-  stdout: { write(chunk: string): boolean | void },
-  env: NodeJS.ProcessEnv,
-  providerId: string,
-  json: boolean,
-): Promise<void> {
-  if (!isOAuthProvider(providerId)) {
-    if (json) {
-      writeJson(stdout, {
-        error: `OAuth not supported for provider: ${providerId}`,
-      });
-    } else {
-      writeText(
-        stdout,
-        `OAuth not supported for provider "${providerId}". Supported providers: ${Object.keys(PKCE_CONFIGS).join(", ")}`,
-      );
-    }
-    return;
-  }
-
-  try {
-    const status = await statusForProvider(providerId, env);
-
-    if (json) {
-      writeJson(stdout, status);
-      return;
-    }
-
-    if (status.error) {
-      writeText(stdout, `  ${providerId}: ${status.error}`);
-      return;
-    }
-
-    if (status.refreshed) {
-      writeText(stdout, `  ${providerId}: token was expired, refreshed successfully`);
-    } else {
-      writeText(stdout, `  ${providerId}: token valid`);
-    }
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    if (json) {
-      writeJson(stdout, { error: msg, provider: providerId });
-    } else {
-      writeText(stdout, `  ${providerId}: error checking status: ${msg}`);
-    }
-  }
-}
-
-async function handleLogin(
-  stdout: { write(chunk: string): boolean | void },
-  env: NodeJS.ProcessEnv,
-  provider: string,
-  opts: {
-    json?: boolean;
-    timeout?: string;
-    clientId?: string;
-  },
-): Promise<void> {
-  if (!isOAuthProvider(provider)) {
-    if (opts.json) {
-      writeJson(stdout, {
-        error: `OAuth not supported for provider: ${provider}`,
-      });
-    } else {
-      writeText(
-        stdout,
-        `OAuth not supported for "${provider}". Use one of: ${Object.keys(PKCE_CONFIGS).join(", ")}`,
-      );
-    }
-    return;
-  }
-
-  const config = PKCE_CONFIGS[provider];
-  if (!config) return; // unreachable
-
-  // Resolve client ID
-  const clientId = opts.clientId ?? resolveClientId(provider, env);
-
-  if (!clientId) {
-    const hint = config.clientIdEnvVar
-      ? `Set the ${config.clientIdEnvVar} environment variable.`
-      : "A client ID is required. Register an OAuth app with the provider.";
-    if (opts.json) {
-      writeJson(stdout, {
-        error: `Client ID required for ${provider} OAuth. ${hint}`,
-      });
-    } else {
-      writeText(stdout, `Error: Client ID required for ${provider} OAuth.`);
-      writeText(stdout, hint);
-    }
-    return;
-  }
-
-  const store = createStore(env);
-  const timeoutMs = opts.timeout ? parseInt(opts.timeout, 10) : 5 * 60 * 1000;
-
-  try {
-    const result = await runOAuthLogin({
-      provider,
-      store,
-      clientId,
-      timeoutMs,
-      openBrowser,
-      onAuthorizeUrl(url) {
-        writeText(stdout, "");
-        writeText(stdout, `Opening browser to authorize OffRouter for ${provider}...`);
-        writeText(stdout, "");
-        writeText(stdout, `If the browser does not open, visit:`);
-        writeText(stdout, `  ${url}`);
-        writeText(stdout, "");
-
-        const opened = openBrowser(url);
-        if (!opened) {
-          writeText(stdout, "(Could not open browser automatically. Copy and paste the URL above.)");
-        }
-        writeText(stdout, "Waiting for authorization...");
-      },
-    });
-
-    if (opts.json) {
-      writeJson(stdout, {
-        provider: result.provider,
-        ok: true,
-        redirectUri: result.redirectUri,
-        expiresAt: result.expiresAt,
-        scope: result.scope,
-      });
-    } else {
-      writeText(stdout, "");
-      writeText(stdout, `✓ Login successful for ${provider}.`);
-      writeText(stdout, `  Tokens stored in OffRouter secret store.`);
-      if (result.expiresAt) {
-        const expiresIn = Math.round((result.expiresAt - Date.now()) / 1000 / 60);
-        writeText(stdout, `  Token expires in ${expiresIn} minutes.`);
-      }
-      writeText(stdout, "");
-    }
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-
-    if (opts.json) {
-      writeJson(stdout, {
-        error: msg,
-        provider,
-        ok: false,
-      });
-    } else {
-      writeText(stdout, "");
-      writeText(stdout, `✗ Login failed for ${provider}: ${msg}`);
-      writeText(stdout, "");
-    }
-  }
-}

package/src/commands/mcp.ts

@@ -1,35 +0,0 @@
-import type { Command } from "commander";
-import { runMcpCli } from "offrouter-mcp";
-import type { CommandContext } from "./init.js";
-
-export function registerMcpCommand(
-  program: Command,
-  ctx: () => CommandContext,
-): void {
-  const mcp = program
-    .command("mcp")
-    .description("OffRouter MCP stdio server bridges");
-
-  mcp
-    .command("serve")
-    .description(
-      "Start the OffRouter MCP stdio server (route/delegate/status tools)",
-    )
-    .action(async (_opts: unknown, command: Command) => {
-      const { env, cwd, stdout, stderr } = ctx();
-      // Forward only unknown/passthrough args after `serve`; Commander already
-      // handled --help before invoking this action.
-      const forwarded = command.args ?? [];
-      const code = await runMcpCli(forwarded, {
-        env,
-        cwd,
-        stdout,
-        stderr,
-      });
-      if (code !== 0) {
-        const err = new Error(`MCP server exited with code ${code}`);
-        (err as { exitCode?: number }).exitCode = code;
-        throw err;
-      }
-    });
-}