@loreai/gateway 0.14.0 → 0.14.1

package/src/cli/run.ts

@@ -1,181 +0,0 @@
-/**
- * `lore run [command...]` — start gateway + launch an AI agent.
- *
- * If a command is given, launches it with gateway env vars injected.
- * If no command is given, auto-detects installed agents and either
- * uses the sole one found or prompts the user to pick.
- */
-import { spawn, type ChildProcess } from "node:child_process";
-import { createInterface } from "node:readline";
-import { startGateway, type StartOptions } from "./start";
-import { detectAgents, AGENTS, type DetectedAgent } from "./agents";
-
-// ---------------------------------------------------------------------------
-// Interactive agent picker (TTY only)
-// ---------------------------------------------------------------------------
-
-async function promptAgent(agents: DetectedAgent[]): Promise<DetectedAgent> {
-  console.error("\n[lore] Multiple AI agents detected:\n");
-  for (let i = 0; i < agents.length; i++) {
-    console.error(`  ${i + 1}) ${agents[i].def.displayName} (${agents[i].path})`);
-  }
-  console.error();
-
-  const rl = createInterface({ input: process.stdin, output: process.stderr });
-
-  return new Promise<DetectedAgent>((resolve) => {
-    const ask = () => {
-      rl.question("Choose an agent [1]: ", (answer) => {
-        const trimmed = answer.trim();
-        const idx = trimmed === "" ? 0 : Number.parseInt(trimmed, 10) - 1;
-        if (Number.isInteger(idx) && idx >= 0 && idx < agents.length) {
-          rl.close();
-          resolve(agents[idx]);
-        } else {
-          console.error(`  Invalid choice. Enter 1–${agents.length}.`);
-          ask();
-        }
-      });
-    };
-    ask();
-  });
-}
-
-// ---------------------------------------------------------------------------
-// Resolve what to launch
-// ---------------------------------------------------------------------------
-
-interface LaunchTarget {
-  command: string;
-  args: string[];
-  env: Record<string, string>;
-}
-
-async function resolveLaunchTarget(
-  gatewayUrl: string,
-  cmdArgs: string[],
-): Promise<LaunchTarget | null> {
-  // --- Explicit command given: inject all known env vars ---
-  if (cmdArgs.length > 0) {
-    const env: Record<string, string> = {};
-    for (const agent of AGENTS) {
-      Object.assign(env, agent.envVars(gatewayUrl));
-    }
-    return { command: cmdArgs[0], args: cmdArgs.slice(1), env };
-  }
-
-  // --- No command: auto-detect agents ---
-  const detected = detectAgents();
-
-  if (detected.length === 0) {
-    console.error("[lore] No known AI agents found on PATH.");
-    console.error("[lore] Install one of: Claude Code (claude), Codex (codex), Pi (pi), OpenCode (opencode)");
-    console.error(`[lore] Or run with an explicit command: lore run <command>`);
-    return null;
-  }
-
-  let agent: DetectedAgent;
-
-  if (detected.length === 1) {
-    agent = detected[0];
-    console.error(`[lore] Detected ${agent.def.displayName} at ${agent.path}`);
-  } else if (process.stdin.isTTY) {
-    agent = await promptAgent(detected);
-  } else {
-    // Non-TTY with multiple agents — can't prompt
-    console.error("[lore] Multiple agents detected but stdin is not a TTY.");
-    console.error("[lore] Specify which agent to run: lore run <command>");
-    for (const a of detected) {
-      console.error(`  - ${a.def.displayName}: lore run ${a.def.binary}`);
-    }
-    return null;
-  }
-
-  return {
-    command: agent.def.binary,
-    args: [],
-    env: agent.def.envVars(gatewayUrl),
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Child process management
-// ---------------------------------------------------------------------------
-
-function launchChild(target: LaunchTarget): ChildProcess {
-  const env = { ...process.env, ...target.env };
-
-  const child = spawn(target.command, target.args, {
-    env,
-    stdio: "inherit",
-  });
-
-  return child;
-}
-
-// ---------------------------------------------------------------------------
-// Command entry point
-// ---------------------------------------------------------------------------
-
-export async function commandRun(
-  opts: StartOptions,
-  cmdArgs: string[],
-): Promise<void> {
-  // 1. Start gateway
-  const { config, port, shutdown } = startGateway(opts);
-  const gatewayUrl = `http://${config.host}:${port}`;
-
-  console.error(`[lore] Gateway listening on ${gatewayUrl}`);
-
-  // 2. Resolve what to launch
-  const target = await resolveLaunchTarget(gatewayUrl, cmdArgs);
-
-  if (!target) {
-    // No agent found / non-interactive — fall back to server-only mode
-    console.error("[lore] Running in server-only mode. Point your agent at the gateway manually.");
-    console.error(`[lore]   export ANTHROPIC_BASE_URL=${gatewayUrl}`);
-
-    const onSignal = async () => {
-      await shutdown();
-      process.exit(0);
-    };
-    process.on("SIGINT", () => onSignal());
-    process.on("SIGTERM", () => onSignal());
-
-    // Block forever
-    return new Promise(() => {});
-  }
-
-  // 3. Launch agent child process
-  console.error(`[lore] Launching: ${target.command} ${target.args.join(" ")}`.trimEnd());
-
-  const child = launchChild(target);
-
-  // Forward signals to child
-  const forwardSignal = (signal: NodeJS.Signals) => {
-    child.kill(signal);
-  };
-  process.on("SIGINT", () => forwardSignal("SIGINT"));
-  process.on("SIGTERM", () => forwardSignal("SIGTERM"));
-
-  // Wait for child to exit, then tear down gateway
-  return new Promise<void>((resolve) => {
-    child.on("exit", async (code, signal) => {
-      await shutdown();
-      // Exit with the child's code (or 128 + signal number for signal deaths)
-      if (signal) {
-        const SIGNAL_CODES: Record<string, number> = {
-          SIGHUP: 1, SIGINT: 2, SIGQUIT: 3, SIGTERM: 15,
-        };
-        process.exit(128 + (SIGNAL_CODES[signal] ?? 1));
-      }
-      process.exit(code ?? 0);
-    });
-
-    child.on("error", async (err) => {
-      console.error(`[lore] Failed to launch ${target.command}: ${err.message}`);
-      await shutdown();
-      process.exit(1);
-    });
-  });
-}

package/src/cli/start.ts

@@ -1,82 +0,0 @@
-/**
- * `lore start` — start the gateway server only.
- *
- * Extracted from the old top-level index.ts boot logic.
- */
-import { loadConfig, type GatewayConfig } from "../config";
-import { startServer } from "../server";
-import { resetPipelineState } from "../pipeline";
-
-export interface StartOptions {
-  port?: number;
-  host?: string;
-  debug?: boolean;
-}
-
-/**
- * Start the gateway server, returning the actual port and a shutdown function.
- *
- * Merges CLI options on top of env-var config (CLI takes precedence).
- */
-export function startGateway(opts: StartOptions = {}): {
-  config: GatewayConfig;
-  port: number;
-  shutdown: () => Promise<void>;
-} {
-  const config = loadConfig();
-
-  // CLI overrides
-  if (opts.port !== undefined) config.port = opts.port;
-  if (opts.host !== undefined) config.host = opts.host;
-  if (opts.debug !== undefined) config.debug = opts.debug;
-
-  const server = startServer(config);
-  const actualPort = server.port;
-
-  const shutdown = async () => {
-    console.error("[lore] Shutting down…");
-    server.stop();
-    await resetPipelineState();
-  };
-
-  return { config, port: actualPort, shutdown };
-}
-
-/**
- * Run the `lore start` command — start gateway server and block until
- * SIGINT/SIGTERM.
- */
-export async function commandStart(opts: StartOptions): Promise<never> {
-  const { config, port, shutdown } = startGateway(opts);
-
-  const addr = `http://${config.host}:${port}`;
-  console.error(`[lore] Gateway listening on ${addr}`);
-  console.error(
-    `[lore] Model routing: claude-* → Anthropic, nvidia/* → Nvidia NIM, gpt-* → OpenAI, …`,
-  );
-  console.error("");
-  console.error("[lore] Point your AI agent at the gateway:");
-  console.error(`  export ANTHROPIC_BASE_URL=${addr}`);
-  console.error(`  export OPENAI_BASE_URL=${addr}/v1`);
-  console.error("");
-  console.error("[lore] Configuration (environment variables):");
-  console.error(`  LORE_LISTEN_PORT        Port to listen on (current: ${port})`);
-  console.error(`  LORE_LISTEN_HOST        Host to bind to (current: ${config.host})`);
-  console.error(`  LORE_UPSTREAM_ANTHROPIC Anthropic API URL (current: ${config.upstreamAnthropic})`);
-  console.error(`  LORE_UPSTREAM_OPENAI    OpenAI API URL (current: ${config.upstreamOpenAI})`);
-  console.error(`  LORE_IDLE_TIMEOUT       Idle timeout in seconds (current: ${config.idleTimeoutSeconds})`);
-  console.error(`  LORE_DEBUG              Enable debug logging (current: ${config.debug})`);
-  console.error(`  LORE_BATCH_DISABLED     Disable batch background work (current: ${process.env.LORE_BATCH_DISABLED === "1"})`);
-
-  // Block until signal
-  const onSignal = async () => {
-    await shutdown();
-    process.exit(0);
-  };
-
-  process.on("SIGINT", () => onSignal());
-  process.on("SIGTERM", () => onSignal());
-
-  // Keep the process alive (Bun.serve already does this, but be explicit)
-  return new Promise(() => {});
-}

package/src/cli/upgrade.ts

@@ -1,311 +0,0 @@
-/**
- * `lore upgrade [version]` — self-update command.
- *
- * Self-update the Lore CLI to the latest or a specific version.
- * After upgrading, replaces the running binary atomically.
- *
- * Supports two release channels:
- * - stable (default): tracks the latest GitHub release
- * - nightly: tracks the rolling nightly prerelease from GHCR
- *
- * The channel can be set via --channel or by passing "nightly"/"stable"
- * as the version argument. The choice is persisted in ~/.lore/channel.
- *
- * Flags:
- *   --check    Check for updates without installing
- *   --force    Force re-download even if up to date
- *   --offline  Upgrade from cached patches (no network)
- *   --channel  Set release channel (stable or nightly)
- *
- * Adapted from Sentry CLI's upgrade command — stripped of brew/npm
- * detection, setup spawning, release notes, and Sentry SDK telemetry.
- */
-
-import { parseArgs } from "node:util";
-import { dirname } from "node:path";
-import { VERSION } from "./version";
-import {
-  isDowngrade,
-  installBinary,
-  determineInstallDir,
-  releaseLock,
-} from "./lib/binary";
-import { UpgradeError } from "./lib/errors";
-import {
-  executeUpgrade,
-  fetchLatestVersion,
-  getCurlInstallPaths,
-  getReleaseChannel,
-  NIGHTLY_TAG,
-  type OfflineMode,
-  type ReleaseChannel,
-  setReleaseChannel,
-  versionExists,
-  VERSION_PREFIX_REGEX,
-} from "./lib/upgrade";
-
-/** Special version strings that select a channel */
-const CHANNEL_VERSIONS = new Set(["nightly", "stable"]);
-
-// ---------------------------------------------------------------------------
-// Flag parsing
-// ---------------------------------------------------------------------------
-
-interface UpgradeFlags {
-  check: boolean;
-  force: boolean;
-  offline: boolean;
-  channel?: string;
-}
-
-function parseUpgradeFlags(args: string[]): {
-  flags: UpgradeFlags;
-  versionArg: string | undefined;
-} {
-  const { values, positionals } = parseArgs({
-    args,
-    options: {
-      check: { type: "boolean", default: false },
-      force: { type: "boolean", default: false },
-      offline: { type: "boolean", default: false },
-      channel: { type: "string" },
-    },
-    allowPositionals: true,
-    strict: false,
-  });
-
-  return {
-    flags: {
-      check: !!values.check,
-      force: !!values.force,
-      offline: !!values.offline,
-      channel: values.channel as string | undefined,
-    },
-    versionArg: positionals[0],
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Channel + version resolution
-// ---------------------------------------------------------------------------
-
-function resolveChannelAndVersion(
-  versionArg: string | undefined,
-  channelFlag: string | undefined,
-): {
-  channel: ReleaseChannel;
-  cleanVersionArg: string | undefined;
-} {
-  // "nightly" and "stable" as positional args select the channel
-  const lower = versionArg?.toLowerCase();
-  if (lower === "nightly" || lower === "stable") {
-    return { channel: lower, cleanVersionArg: undefined };
-  }
-
-  // --channel flag overrides persisted channel
-  if (channelFlag === "nightly" || channelFlag === "stable") {
-    return { channel: channelFlag, cleanVersionArg: versionArg };
-  }
-
-  return {
-    channel: getReleaseChannel(),
-    cleanVersionArg: versionArg,
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Cached version for offline mode
-// ---------------------------------------------------------------------------
-
-/** Simple file-based cache for last-known latest version */
-function getCachedLatestVersion(): string | null {
-  try {
-    const fs = require("node:fs");
-    const path = require("node:path");
-    const { getConfigDir } = require("./lib/binary");
-    const content = fs
-      .readFileSync(path.join(getConfigDir(), "latest-version"), "utf-8")
-      .trim();
-    return content || null;
-  } catch {
-    return null;
-  }
-}
-
-function setCachedLatestVersion(version: string): void {
-  try {
-    const fs = require("node:fs");
-    const path = require("node:path");
-    const { getConfigDir } = require("./lib/binary");
-    const dir = getConfigDir();
-    fs.mkdirSync(dir, { recursive: true });
-    fs.writeFileSync(path.join(dir, "latest-version"), version, "utf-8");
-  } catch {
-    // Best-effort
-  }
-}
-
-function resolveOfflineTarget(versionArg: string | undefined): string {
-  if (versionArg) {
-    return versionArg.replace(VERSION_PREFIX_REGEX, "");
-  }
-  const cached = getCachedLatestVersion();
-  if (!cached) {
-    throw new UpgradeError(
-      "network_error",
-      "No cached version available. Run `lore upgrade` with network access first, then retry with --offline.",
-    );
-  }
-  return cached;
-}
-
-// ---------------------------------------------------------------------------
-// Main command
-// ---------------------------------------------------------------------------
-
-export async function commandUpgrade(args: string[]): Promise<void> {
-  const { flags, versionArg: rawVersionArg } = parseUpgradeFlags(args);
-
-  const { channel, cleanVersionArg } = resolveChannelAndVersion(
-    rawVersionArg,
-    flags.channel,
-  );
-
-  const currentChannel = getReleaseChannel();
-  const channelChanged = channel !== currentChannel;
-
-  console.error(`[lore] Current version: ${VERSION}`);
-  console.error(`[lore] Channel: ${channel}`);
-
-  // Resolve target version
-  let target: string;
-  let offline: OfflineMode = false;
-
-  if (flags.offline) {
-    // Read cached version BEFORE persisting channel
-    target = resolveOfflineTarget(cleanVersionArg);
-    offline = "explicit";
-    console.error(`[lore] Offline mode: using cached target ${target}`);
-  } else {
-    try {
-      const latest = await fetchLatestVersion(channel);
-      target = cleanVersionArg?.replace(VERSION_PREFIX_REGEX, "") ?? latest;
-
-      // Cache the latest version for future offline use
-      setCachedLatestVersion(latest);
-    } catch (error) {
-      // Try offline fallback
-      if (error instanceof UpgradeError && error.reason === "network_error") {
-        try {
-          target = resolveOfflineTarget(cleanVersionArg);
-          offline = "network-fallback";
-          console.error(
-            "[lore] Network unavailable, falling back to cached upgrade target",
-          );
-        } catch {
-          throw error; // Re-throw original network error
-        }
-      } else {
-        throw error;
-      }
-    }
-  }
-
-  // Persist channel preference
-  if (channelChanged || CHANNEL_VERSIONS.has(rawVersionArg ?? "")) {
-    setReleaseChannel(channel);
-  }
-
-  // --check: just report status
-  if (flags.check) {
-    if (VERSION === target) {
-      console.error(`[lore] Already up to date (${VERSION})`);
-    } else {
-      const direction = isDowngrade(VERSION, target)
-        ? "Downgrade"
-        : "Update";
-      console.error(`[lore] ${direction} available: ${VERSION} -> ${target}`);
-      console.error(`[lore] Run 'lore upgrade' to update.`);
-    }
-    if (offline) {
-      console.error("[lore] (resolved from cache — network unavailable)");
-    }
-    return;
-  }
-
-  // Already on target — unless forced or switching channels
-  if (VERSION === target && !flags.force && !channelChanged) {
-    console.error(`[lore] Already up to date (${VERSION})`);
-    return;
-  }
-
-  // Validate pinned version exists (skip for channel keywords)
-  if (
-    cleanVersionArg &&
-    !CHANNEL_VERSIONS.has(cleanVersionArg) &&
-    !offline
-  ) {
-    const exists = await versionExists(target, channel);
-    if (!exists) {
-      throw new UpgradeError(
-        "version_not_found",
-        `Version ${target} not found`,
-      );
-    }
-  }
-
-  const downgrade = isDowngrade(VERSION, target);
-  const verb = downgrade ? "Downgrading" : "Upgrading";
-  console.error(`[lore] ${verb} to ${target}...`);
-
-  // Use the rolling "nightly" tag only when upgrading to latest nightly
-  const downloadTag =
-    channel === "nightly" && !cleanVersionArg ? NIGHTLY_TAG : undefined;
-
-  // Download the new binary
-  const downloadResult = await executeUpgrade(target, downloadTag, offline);
-
-  if (downloadResult.patchBytes) {
-    console.error(
-      `[lore] Applied delta patch (${formatBytes(downloadResult.patchBytes)} downloaded)`,
-    );
-  }
-
-  // Install: replace the current binary atomically
-  try {
-    const currentInstallDir = dirname(getCurlInstallPaths().installPath);
-    const installDir = determineInstallDir(
-      require("node:os").homedir(),
-      process.env,
-    );
-    // Use current install dir if we're already in a known location
-    const targetDir = process.execPath.startsWith(currentInstallDir)
-      ? currentInstallDir
-      : installDir;
-
-    const installedPath = await installBinary(
-      downloadResult.tempBinaryPath,
-      targetDir,
-    );
-
-    console.error(
-      `[lore] ${downgrade ? "Downgraded" : "Upgraded"} successfully: ${VERSION} -> ${target}`,
-    );
-    console.error(`[lore] Binary installed at: ${installedPath}`);
-    if (offline) {
-      console.error("[lore] (upgraded from cached patches)");
-    }
-  } finally {
-    releaseLock(downloadResult.lockPath);
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function formatBytes(bytes: number): string {
-  if (bytes < 1024) return `${bytes} B`;
-  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
-  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
-}

package/src/cli/version.ts

@@ -1,22 +0,0 @@
-/**
- * CLI version — replaced at build time by esbuild `define`.
- *
- * During development (running via `bun run src/index.ts`), falls back
- * to reading package.json at runtime.
- */
-
-// esbuild replaces this with a string literal at bundle time.
-// In dev mode the identifier is left as-is and we fall back below.
-declare const LORE_CLI_VERSION: string | undefined;
-
-function readVersionFromPackageJson(): string {
-  try {
-    const pkg = require("../../package.json") as { version?: string };
-    return pkg.version ?? "dev";
-  } catch {
-    return "dev";
-  }
-}
-
-export const VERSION: string =
-  typeof LORE_CLI_VERSION !== "undefined" ? LORE_CLI_VERSION : readVersionFromPackageJson();