@openhoo/hoopilot 0.3.1 → 0.4.0

package/dist/index.cjs

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,6 +17,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
@@ -23,270 +33,126 @@ __export(index_exports, {
   CopilotAuth: () => CopilotAuth,
   CopilotAuthError: () => CopilotAuthError,
   CopilotClient: () => CopilotClient,
+  DEFAULT_LOG_FORMAT: () => DEFAULT_LOG_FORMAT,
+  DEFAULT_LOG_LEVEL: () => DEFAULT_LOG_LEVEL,
   DEFAULT_MODEL: () => DEFAULT_MODEL,
+  authStorePath: () => authStorePath,
   chatCompletionToCompletion: () => chatCompletionToCompletion,
   chatCompletionToResponse: () => chatCompletionToResponse,
   completionsRequestToChatCompletion: () => completionsRequestToChatCompletion,
   createHoopilotHandler: () => createHoopilotHandler,
+  createHoopilotLogger: () => createHoopilotLogger,
   fallbackModels: () => fallbackModels,
+  githubCopilotDeviceLogin: () => githubCopilotDeviceLogin,
+  noopLogger: () => noopLogger,
   normalizeModelsResponse: () => normalizeModelsResponse,
+  parseLogFormat: () => parseLogFormat,
+  parseLogLevel: () => parseLogLevel,
+  readStoredCopilotAuth: () => readStoredCopilotAuth,
   responsesRequestToChatCompletion: () => responsesRequestToChatCompletion,
   responsesStreamFromChatStream: () => responsesStreamFromChatStream,
-  splitCommand: () => splitCommand,
-  startHoopilotServer: () => startHoopilotServer
+  startHoopilotServer: () => startHoopilotServer,
+  writeStoredCopilotAuth: () => writeStoredCopilotAuth
 });
 module.exports = __toCommonJS(index_exports);
 
+// src/auth-store.ts
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+function authStorePath(env = process.env) {
+  if (env.HOOPILOT_AUTH_FILE) {
+    return env.HOOPILOT_AUTH_FILE;
+  }
+  const base = env.XDG_CONFIG_HOME ?? env.APPDATA ?? (env.HOME ? (0, import_node_path.join)(env.HOME, ".config") : (0, import_node_path.join)(process.cwd(), ".config"));
+  return (0, import_node_path.join)(base, "hoopilot", "auth.json");
+}
+function readStoredCopilotAuth(path = authStorePath()) {
+  try {
+    const parsed = JSON.parse((0, import_node_fs.readFileSync)(path, "utf8"));
+    if (!parsed || typeof parsed !== "object") {
+      return void 0;
+    }
+    const token = typeof parsed.token === "string" ? parsed.token.trim() : "";
+    if (!token) {
+      return void 0;
+    }
+    return {
+      apiBaseUrl: typeof parsed.apiBaseUrl === "string" ? parsed.apiBaseUrl : void 0,
+      createdAt: typeof parsed.createdAt === "string" ? parsed.createdAt : void 0,
+      githubDomain: typeof parsed.githubDomain === "string" ? parsed.githubDomain : void 0,
+      source: typeof parsed.source === "string" ? parsed.source : void 0,
+      token
+    };
+  } catch {
+    return void 0;
+  }
+}
+function writeStoredCopilotAuth(auth, path = authStorePath()) {
+  (0, import_node_fs.mkdirSync)((0, import_node_path.dirname)(path), { recursive: true });
+  (0, import_node_fs.writeFileSync)(
+    path,
+    `${JSON.stringify(
+      {
+        ...auth,
+        createdAt: auth.createdAt ?? (/* @__PURE__ */ new Date()).toISOString()
+      },
+      null,
+      2
+    )}
+`,
+    { mode: 384 }
+  );
+  try {
+    (0, import_node_fs.chmodSync)(path, 384);
+  } catch {
+  }
+}
+
 // src/auth.ts
-var import_node_child_process = require("child_process");
-var DEFAULT_COPILOT_API_BASE_URL = "https://api.individual.githubcopilot.com";
-var DEFAULT_TOKEN_EXCHANGE_URL = "https://api.github.com/copilot_internal/v2/token";
+var DEFAULT_COPILOT_API_BASE_URL = "https://api.githubcopilot.com";
 var REFRESH_SKEW_MS = 6e4;
+var STORED_TOKEN_TTL_MS = 10 * 6e4;
 var CopilotAuthError = class extends Error {
   constructor(message) {
     super(message);
     this.name = "CopilotAuthError";
   }
 };
-var CopilotTokenExchangeHttpError = class extends CopilotAuthError {
-};
 var CopilotAuth = class {
-  #authMode;
+  #authStorePath;
   #copilotApiBaseUrl;
-  #copilotToken;
-  #env;
-  #fetch;
-  #githubToken;
-  #githubTokenCommand;
-  #logger;
-  #tokenExchangeUrl;
   #cachedAccess;
   constructor(options = {}) {
-    this.#authMode = options.authMode ?? "auto";
+    this.#authStorePath = options.authStorePath ?? options.env?.HOOPILOT_AUTH_FILE;
     this.#copilotApiBaseUrl = trimTrailingSlash(
       options.copilotApiBaseUrl ?? options.env?.COPILOT_API_BASE_URL ?? DEFAULT_COPILOT_API_BASE_URL
     );
-    this.#copilotToken = options.copilotToken;
-    this.#env = options.env ?? process.env;
-    this.#fetch = options.fetch ?? fetch;
-    this.#githubToken = options.githubToken;
-    this.#githubTokenCommand = options.githubTokenCommand ?? "gh auth token";
-    this.#logger = options.logger;
-    this.#tokenExchangeUrl = options.tokenExchangeUrl ?? options.env?.COPILOT_TOKEN_EXCHANGE_URL ?? DEFAULT_TOKEN_EXCHANGE_URL;
   }
   async getAccess() {
     if (this.#cachedAccess && this.#cachedAccess.expiresAtMs - REFRESH_SKEW_MS > Date.now()) {
       return this.#cachedAccess;
     }
-    const directCopilotToken = this.#resolveDirectCopilotToken();
-    if (directCopilotToken) {
-      return this.#cacheAccess({
-        apiBaseUrl: this.#copilotApiBaseUrl,
-        expiresAtMs: Date.now() + 10 * 6e4,
-        source: "copilot-token",
-        token: directCopilotToken
-      });
-    }
-    if (this.#authMode === "copilot-token") {
-      throw new CopilotAuthError("COPILOT_API_TOKEN or GITHUB_COPILOT_API_TOKEN is required.");
-    }
-    const githubToken = this.#resolveGithubToken();
-    if (!githubToken) {
-      throw new CopilotAuthError(
-        "No Copilot credential found. Set COPILOT_API_TOKEN, set COPILOT_GITHUB_TOKEN from gh auth token, or sign in with gh auth login."
-      );
-    }
-    if (isPersonalAccessToken(githubToken)) {
-      throw new CopilotAuthError(
-        "GitHub personal access tokens are not supported for Copilot authentication. Use gh auth login or COPILOT_API_TOKEN."
-      );
-    }
-    try {
-      return this.#cacheAccess(await this.#exchangeGithubToken(githubToken));
-    } catch (error) {
-      if (!(error instanceof CopilotTokenExchangeHttpError)) {
-        throw error;
-      }
-      this.#logger?.warn(
-        `Copilot token exchange failed; falling back to GitHub CLI token mode: ${errorMessage(
-          error
-        )}`
-      );
+    const stored = readStoredCopilotAuth(this.#authStorePath);
+    if (stored) {
       return this.#cacheAccess({
-        apiBaseUrl: this.#copilotApiBaseUrl,
-        expiresAtMs: Date.now() + 10 * 6e4,
-        source: "direct-github-token",
-        token: githubToken
+        apiBaseUrl: trimTrailingSlash(stored.apiBaseUrl ?? this.#copilotApiBaseUrl),
+        expiresAtMs: Date.now() + STORED_TOKEN_TTL_MS,
+        source: "github-copilot-oauth",
+        token: stored.token
       });
     }
+    throw new CopilotAuthError(
+      "No GitHub Copilot OAuth credential found. Run `hoopilot login` to sign in through your browser."
+    );
   }
   #cacheAccess(access) {
     this.#cachedAccess = access;
     return access;
   }
-  async #exchangeGithubToken(githubToken) {
-    const response = await this.#fetch(this.#tokenExchangeUrl, {
-      headers: {
-        accept: "application/vnd.github+json",
-        authorization: `token ${githubToken}`,
-        "editor-plugin-version": "hoopilot/0.1.0",
-        "editor-version": "Hoopilot/0.1.0",
-        "user-agent": "hoopilot/0.1.0"
-      },
-      method: "GET"
-    });
-    if (!response.ok) {
-      throw new CopilotTokenExchangeHttpError(
-        `GitHub Copilot token exchange failed with ${response.status}: ${await safeResponseText(
-          response
-        )}`
-      );
-    }
-    const body = asRecord(await response.json());
-    const token = getString(body, "token");
-    if (!token) {
-      throw new CopilotAuthError("GitHub Copilot token exchange response did not include a token.");
-    }
-    return {
-      apiBaseUrl: endpointFromResponse(body) ?? this.#copilotApiBaseUrl,
-      expiresAtMs: expiresAtFromResponse(body),
-      source: "github-token",
-      token
-    };
-  }
-  #resolveDirectCopilotToken() {
-    return firstNonEmpty(
-      this.#copilotToken,
-      this.#env.COPILOT_API_TOKEN,
-      this.#env.GITHUB_COPILOT_API_TOKEN,
-      this.#env.GITHUB_COPILOT_TOKEN
-    );
-  }
-  #resolveGithubToken() {
-    return firstNonEmpty(
-      this.#githubToken,
-      this.#env.COPILOT_GITHUB_TOKEN,
-      this.#env.GITHUB_COPILOT_GITHUB_TOKEN,
-      this.#readGithubTokenCommand()
-    );
-  }
-  #readGithubTokenCommand() {
-    if (this.#githubTokenCommand === false) {
-      return void 0;
-    }
-    const parts = splitCommand(this.#githubTokenCommand);
-    const [command, ...args] = parts;
-    if (!command) {
-      return void 0;
-    }
-    try {
-      const output = (0, import_node_child_process.execFileSync)(command, args, {
-        encoding: "utf8",
-        stdio: ["ignore", "pipe", "ignore"],
-        timeout: 5e3
-      });
-      return output.trim() || void 0;
-    } catch {
-      return void 0;
-    }
-  }
 };
-function splitCommand(command) {
-  const parts = [];
-  let current = "";
-  let quote;
-  let escaping = false;
-  for (const character of command.trim()) {
-    if (escaping) {
-      current += character;
-      escaping = false;
-      continue;
-    }
-    if (character === "\\") {
-      escaping = true;
-      continue;
-    }
-    if (quote) {
-      if (character === quote) {
-        quote = void 0;
-      } else {
-        current += character;
-      }
-      continue;
-    }
-    if (character === "'" || character === '"') {
-      quote = character;
-      continue;
-    }
-    if (/\s/.test(character)) {
-      if (current) {
-        parts.push(current);
-        current = "";
-      }
-      continue;
-    }
-    current += character;
-  }
-  if (current) {
-    parts.push(current);
-  }
-  return parts;
-}
-function endpointFromResponse(body) {
-  const endpoints = asRecord(body.endpoints);
-  const apiUrl = getString(endpoints, "api") ?? getString(endpoints, "proxy");
-  return apiUrl ? trimTrailingSlash(apiUrl) : void 0;
-}
-function expiresAtFromResponse(body) {
-  const expiresAt = body.expires_at;
-  if (typeof expiresAt === "number") {
-    return expiresAt < 1e10 ? expiresAt * 1e3 : expiresAt;
-  }
-  if (typeof expiresAt === "string") {
-    const asNumber = Number(expiresAt);
-    if (Number.isFinite(asNumber)) {
-      return asNumber < 1e10 ? asNumber * 1e3 : asNumber;
-    }
-    const parsed = Date.parse(expiresAt);
-    if (Number.isFinite(parsed)) {
-      return parsed;
-    }
-  }
-  const refreshIn = body.refresh_in;
-  if (typeof refreshIn === "number" && Number.isFinite(refreshIn)) {
-    return Date.now() + refreshIn * 1e3;
-  }
-  return Date.now() + 10 * 6e4;
-}
-function firstNonEmpty(...values) {
-  for (const value of values) {
-    const trimmed = value?.trim();
-    if (trimmed) {
-      return trimmed;
-    }
-  }
-  return void 0;
-}
-function asRecord(value) {
-  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
-}
-function getString(record, key) {
-  const value = record[key];
-  return typeof value === "string" && value ? value : void 0;
-}
 function trimTrailingSlash(value) {
   return value.replace(/\/+$/, "");
 }
-async function safeResponseText(response) {
-  const text = await response.text();
-  return text.slice(0, 500);
-}
-function isPersonalAccessToken(token) {
-  return token.startsWith("github_pat_") || token.startsWith("ghp_");
-}
-function errorMessage(error) {
-  return error instanceof Error ? error.message : String(error);
-}
 
 // src/copilot.ts
 var CopilotClient = class {
@@ -335,6 +201,7 @@ var CopilotClient = class {
     headers.set("editor-version", "Hoopilot/0.1.0");
     headers.set("openai-intent", "conversation-panel");
     headers.set("user-agent", "hoopilot/0.1.0");
+    headers.set("x-github-api-version", "2026-06-01");
     return this.#fetch(`${access.apiBaseUrl}${path}`, {
       ...init,
       headers
@@ -342,6 +209,226 @@ var CopilotClient = class {
   }
 };
 
+// src/github-device.ts
+var import_promises = require("timers/promises");
+var DEFAULT_GITHUB_COPILOT_CLIENT_ID = "Iv23lijnNxm2e9UX3CF8";
+var DEFAULT_GITHUB_DOMAIN = "github.com";
+var DEVICE_GRANT_TYPE = "urn:ietf:params:oauth:grant-type:device_code";
+var POLLING_SAFETY_MARGIN_MS = 3e3;
+async function githubCopilotDeviceLogin(options = {}) {
+  const env = options.env ?? process.env;
+  const fetcher = options.fetch ?? fetch;
+  const sleeper = options.sleep ?? import_promises.setTimeout;
+  const domain = normalizeDomain(
+    options.domain ?? env.HOOPILOT_GITHUB_DOMAIN ?? DEFAULT_GITHUB_DOMAIN
+  );
+  const clientId = options.clientId ?? env.HOOPILOT_GITHUB_CLIENT_ID ?? env.COPILOT_GITHUB_CLIENT_ID ?? DEFAULT_GITHUB_COPILOT_CLIENT_ID;
+  const device = await requestDeviceCode(fetcher, domain, clientId);
+  const verificationUrl = device.verification_uri;
+  const userCode = device.user_code;
+  const deviceCode = device.device_code;
+  if (!verificationUrl || !userCode || !deviceCode) {
+    throw new Error("GitHub device authorization response is missing required fields.");
+  }
+  options.logger?.info(`First copy your one-time code: ${userCode}`);
+  options.logger?.info(`Open ${verificationUrl} in your browser to authorize Hoopilot.`);
+  await options.openBrowser?.(verificationUrl);
+  return {
+    domain,
+    token: await pollForAccessToken(fetcher, sleeper, domain, clientId, {
+      deviceCode,
+      expiresIn: positiveSeconds(device.expires_in, 900),
+      interval: positiveSeconds(device.interval, 5)
+    })
+  };
+}
+async function requestDeviceCode(fetcher, domain, clientId) {
+  const response = await fetcher(`https://${domain}/login/device/code`, {
+    body: JSON.stringify({
+      client_id: clientId,
+      scope: "read:user"
+    }),
+    headers: oauthHeaders(),
+    method: "POST"
+  });
+  if (!response.ok) {
+    throw new Error(
+      `GitHub device authorization failed with ${response.status}: ${await safeResponseText(
+        response
+      )}`
+    );
+  }
+  return await response.json();
+}
+async function pollForAccessToken(fetcher, sleeper, domain, clientId, device) {
+  let intervalMs = device.interval * 1e3 + POLLING_SAFETY_MARGIN_MS;
+  const deadline = Date.now() + device.expiresIn * 1e3;
+  while (Date.now() < deadline) {
+    await sleeper(intervalMs);
+    const response = await fetcher(`https://${domain}/login/oauth/access_token`, {
+      body: JSON.stringify({
+        client_id: clientId,
+        device_code: device.deviceCode,
+        grant_type: DEVICE_GRANT_TYPE
+      }),
+      headers: oauthHeaders(),
+      method: "POST"
+    });
+    if (!response.ok) {
+      throw new Error(
+        `GitHub device token exchange failed with ${response.status}: ${await safeResponseText(
+          response
+        )}`
+      );
+    }
+    const data = await response.json();
+    if (data.access_token) {
+      return data.access_token;
+    }
+    if (data.error === "authorization_pending") {
+      continue;
+    }
+    if (data.error === "slow_down") {
+      intervalMs = positiveSeconds(data.interval, device.interval + 5) * 1e3 + POLLING_SAFETY_MARGIN_MS;
+      continue;
+    }
+    if (data.error === "expired_token") {
+      throw new Error("GitHub device login expired. Run `hoopilot login` again.");
+    }
+    if (data.error === "access_denied") {
+      throw new Error("GitHub device login was cancelled.");
+    }
+    if (data.error) {
+      throw new Error(data.error_description || `GitHub device login failed: ${data.error}`);
+    }
+  }
+  throw new Error("GitHub device login timed out. Run `hoopilot login` again.");
+}
+function oauthHeaders() {
+  const headers = new Headers();
+  headers.set("accept", "application/json");
+  headers.set("content-type", "application/json");
+  headers.set("user-agent", "hoopilot");
+  return headers;
+}
+function normalizeDomain(value) {
+  return value.replace(/^https?:\/\//, "").replace(/\/+$/, "");
+}
+function positiveSeconds(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : fallback;
+}
+async function safeResponseText(response) {
+  const text = await response.text();
+  return text.slice(0, 500);
+}
+
+// src/logger.ts
+var import_pino = __toESM(require("pino"), 1);
+var import_pino_pretty = __toESM(require("pino-pretty"), 1);
+var DEFAULT_LOG_FORMAT = "pretty";
+var DEFAULT_LOG_LEVEL = "info";
+var LOG_FORMATS = ["json", "pretty"];
+var LOG_LEVELS = ["trace", "debug", "info", "warn", "error", "fatal", "silent"];
+var REDACT_PATHS = [
+  "apiKey",
+  "authorization",
+  "cookie",
+  "headers.authorization",
+  "headers.Authorization",
+  "headers.cookie",
+  "headers.Cookie",
+  "headers.x-api-key",
+  "headers.X-Api-Key",
+  "token",
+  "*.apiKey",
+  "*.authorization",
+  "*.cookie",
+  "*.token",
+  "*.headers.authorization",
+  "*.headers.Authorization",
+  "*.headers.cookie",
+  "*.headers.Cookie",
+  "*.headers.x-api-key",
+  "*.headers.X-Api-Key"
+];
+var noopLogger = {
+  child: () => noopLogger,
+  debug: () => {
+  },
+  error: () => {
+  },
+  fatal: () => {
+  },
+  info: () => {
+  },
+  trace: () => {
+  },
+  warn: () => {
+  }
+};
+function createHoopilotLogger(options = {}) {
+  const env = options.env ?? process.env;
+  const level = parseLogLevel(options.level ?? env.HOOPILOT_LOG_LEVEL);
+  const format = parseLogFormat(options.format ?? env.HOOPILOT_LOG_FORMAT);
+  const pinoOptions = {
+    base: {
+      service: "hoopilot",
+      ...options.base
+    },
+    level,
+    redact: {
+      censor: "[Redacted]",
+      paths: REDACT_PATHS
+    },
+    timestamp: import_pino.default.stdTimeFunctions.isoTime
+  };
+  if (format === "pretty") {
+    return (0, import_pino.default)(
+      pinoOptions,
+      (0, import_pino_pretty.default)({
+        colorize: options.colorize ?? process.stderr.isTTY,
+        destination: options.stream ?? 1,
+        ignore: "pid,hostname",
+        singleLine: true,
+        translateTime: "SYS:standard"
+      })
+    );
+  }
+  if (options.stream) {
+    return (0, import_pino.default)(pinoOptions, options.stream);
+  }
+  return (0, import_pino.default)(pinoOptions);
+}
+function parseLogFormat(value) {
+  if (!value) {
+    return DEFAULT_LOG_FORMAT;
+  }
+  if (isLogFormat(value)) {
+    return value;
+  }
+  throw new Error(`Invalid log format: ${value}. Expected one of: ${LOG_FORMATS.join(", ")}.`);
+}
+function parseLogLevel(value) {
+  if (!value) {
+    return DEFAULT_LOG_LEVEL;
+  }
+  if (isLogLevel(value)) {
+    return value;
+  }
+  throw new Error(`Invalid log level: ${value}. Expected one of: ${LOG_LEVELS.join(", ")}.`);
+}
+function shouldCreateLogger(options) {
+  return Boolean(
+    options.logger || options.logFormat || options.logLevel || options.env?.HOOPILOT_LOG_FORMAT || options.env?.HOOPILOT_LOG_LEVEL
+  );
+}
+function isLogFormat(value) {
+  return LOG_FORMATS.includes(value);
+}
+function isLogLevel(value) {
+  return LOG_LEVELS.includes(value);
+}
+
 // src/openai.ts
 var DEFAULT_MODEL = "gpt-4.1";
 function responsesRequestToChatCompletion(request) {
@@ -360,8 +447,8 @@ function responsesRequestToChatCompletion(request) {
     metadata: request.metadata,
     model: contentToText(request.model) || DEFAULT_MODEL,
     presence_penalty: request.presence_penalty,
-    reasoning_effort: asRecord2(request.reasoning).effort,
-    response_format: asRecord2(request.text).format,
+    reasoning_effort: asRecord(request.reasoning).effort,
+    response_format: asRecord(request.text).format,
     seed: request.seed,
     stream: request.stream === true,
     temperature: request.temperature,
@@ -383,7 +470,7 @@ function completionsRequestToChatCompletion(request) {
 function chatCompletionToResponse(completion, responseId) {
   const id = responseId ?? `resp_${randomId()}`;
   const choice = firstChoice(completion);
-  const message = asRecord2(choice.message);
+  const message = asRecord(choice.message);
   const model = contentToText(completion.model) || DEFAULT_MODEL;
   const output = outputItemsFromMessage(message);
   const usage = responseUsage(completion.usage);
@@ -410,7 +497,7 @@ function chatCompletionToResponse(completion, responseId) {
 }
 function chatCompletionToCompletion(completion) {
   const choice = firstChoice(completion);
-  const message = asRecord2(choice.message);
+  const message = asRecord(choice.message);
   return removeUndefined({
     choices: [
       {
@@ -428,9 +515,9 @@ function chatCompletionToCompletion(completion) {
   });
 }
 function normalizeModelsResponse(upstream) {
-  const record = asRecord2(upstream);
+  const record = asRecord(upstream);
   const data = Array.isArray(record.data) ? record.data : Array.isArray(upstream) ? upstream : [];
-  const models = data.map((model) => asRecord2(model)).filter((model) => typeof model.id === "string").map((model) => ({
+  const models = data.map((model) => asRecord(model)).filter((model) => typeof model.id === "string").map((model) => ({
     created: model.created ?? 0,
     id: model.id,
     object: "model",
@@ -579,7 +666,7 @@ function inputToMessages(input) {
   }
   const messages = [];
   for (const item of input) {
-    const record = asRecord2(item);
+    const record = asRecord(item);
     if (record.type === "function_call_output") {
       messages.push({
         content: contentToText(record.output),
@@ -621,7 +708,7 @@ function chatMessageContent(content) {
   }
   const parts = [];
   for (const part of content) {
-    const record = asRecord2(part);
+    const record = asRecord(part);
     const type = contentToText(record.type);
     if (type === "input_text" || type === "output_text" || type === "text") {
       parts.push({ text: contentToText(record.text), type: "text" });
@@ -679,7 +766,7 @@ function chatTools(tools) {
   if (!Array.isArray(tools)) {
     return void 0;
   }
-  const converted = tools.map((tool) => asRecord2(tool)).filter((tool) => tool.type === "function").map((tool) => ({
+  const converted = tools.map((tool) => asRecord(tool)).filter((tool) => tool.type === "function").map((tool) => ({
     function: removeUndefined({
       description: tool.description,
       name: tool.name,
@@ -694,7 +781,7 @@ function chatToolChoice(toolChoice) {
   if (typeof toolChoice === "string" || toolChoice === void 0) {
     return toolChoice;
   }
-  const record = asRecord2(toolChoice);
+  const record = asRecord(toolChoice);
   if (record.type === "function" && typeof record.name === "string") {
     return { function: { name: record.name }, type: "function" };
   }
@@ -708,8 +795,8 @@ function outputItemsFromMessage(message) {
   }
   const toolCalls = Array.isArray(message.tool_calls) ? message.tool_calls : [];
   for (const toolCall of toolCalls) {
-    const record = asRecord2(toolCall);
-    const fn = asRecord2(record.function);
+    const record = asRecord(toolCall);
+    const fn = asRecord(record.function);
     output.push(
       functionCallItem({
         arguments: contentToText(fn.arguments),
@@ -750,10 +837,10 @@ function outputText(output) {
   return output.flatMap((item) => {
     const content = item.content;
     return Array.isArray(content) ? content : [];
-  }).map((part) => contentToText(asRecord2(part).text)).filter(Boolean).join("");
+  }).map((part) => contentToText(asRecord(part).text)).filter(Boolean).join("");
 }
 function responseUsage(usage) {
-  const record = asRecord2(usage);
+  const record = asRecord(usage);
   if (Object.keys(record).length === 0) {
     return null;
   }
@@ -767,7 +854,7 @@ function responseUsage(usage) {
 }
 function firstChoice(completion) {
   const choices = Array.isArray(completion.choices) ? completion.choices : [];
-  return asRecord2(choices[0]);
+  return asRecord(choices[0]);
 }
 function processChatSseLine(line, enqueue, tools, appendText) {
   const trimmed = line.trim();
@@ -783,7 +870,7 @@ function processChatSseLine(line, enqueue, tools, appendText) {
     return;
   }
   const choice = firstChoice(parsed);
-  const delta = asRecord2(choice.delta);
+  const delta = asRecord(choice.delta);
   const content = contentToText(delta.content);
   if (content) {
     appendText(content);
@@ -797,8 +884,8 @@ function processChatSseLine(line, enqueue, tools, appendText) {
   }
   const toolCalls = Array.isArray(delta.tool_calls) ? delta.tool_calls : [];
   for (const toolCall of toolCalls) {
-    const record = asRecord2(toolCall);
-    const fn = asRecord2(record.function);
+    const record = asRecord(toolCall);
+    const fn = asRecord(record.function);
     const index = typeof record.index === "number" ? record.index : tools.size;
     const existing = tools.get(index) ?? {
       arguments: "",
@@ -846,7 +933,7 @@ data: ${JSON.stringify(data)}
 }
 function parseJson(data) {
   try {
-    return asRecord2(JSON.parse(data));
+    return asRecord(JSON.parse(data));
   } catch {
     return void 0;
   }
@@ -854,7 +941,7 @@ function parseJson(data) {
 function removeUndefined(record) {
   return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== void 0));
 }
-function asRecord2(value) {
+function asRecord(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
 function randomId() {
@@ -867,43 +954,111 @@ function epochSeconds() {
 // src/server.ts
 var DEFAULT_HOST = "127.0.0.1";
 var DEFAULT_PORT = 4141;
+var INVALID_JSON_MESSAGE = "Request body must be valid JSON.";
 function createHoopilotHandler(options = {}) {
   const client = new CopilotClient(options);
   const apiKey = options.apiKey ?? options.env?.HOOPILOT_API_KEY;
+  const logger = serverLogger(options);
   return async (request) => {
+    const startedAt = performance.now();
     const url = new URL(request.url);
+    const requestId = requestIdFor(request);
+    const requestLogger = logger.child({
+      method: request.method,
+      path: url.pathname,
+      requestId,
+      route: routeFor(request.method, url.pathname)
+    });
     if (request.method === "OPTIONS") {
-      return new Response(null, { headers: corsHeaders() });
+      return finishResponse(new Response(null, { headers: corsHeaders() }), {
+        logger: requestLogger,
+        requestId,
+        startedAt
+      });
     }
     if (!isAuthorized(request, apiKey)) {
-      return jsonError(401, "invalid_api_key", "Invalid or missing Hoopilot API key.");
+      requestLogger.warn({ event: "http.request.unauthorized" }, "invalid hoopilot api key");
+      return finishResponse(
+        jsonError(401, "invalid_api_key", "Invalid or missing Hoopilot API key."),
+        {
+          logger: requestLogger,
+          requestId,
+          startedAt
+        }
+      );
     }
     try {
       if (request.method === "GET" && (url.pathname === "/" || url.pathname === "/healthz")) {
-        return jsonResponse({
-          name: "hoopilot",
-          object: "health",
-          status: "ok"
-        });
+        return finishResponse(
+          jsonResponse({
+            name: "hoopilot",
+            object: "health",
+            status: "ok"
+          }),
+          { logger: requestLogger, requestId, startedAt }
+        );
       }
       if (request.method === "GET" && url.pathname === "/v1/models") {
-        return await handleModels(client, request.signal);
+        return finishResponse(await handleModels(client, request.signal, requestLogger), {
+          logger: requestLogger,
+          requestId,
+          startedAt
+        });
       }
       if (request.method === "POST" && url.pathname === "/v1/chat/completions") {
-        return await handleChatCompletions(client, request);
+        return finishResponse(await handleChatCompletions(client, request, requestLogger), {
+          logger: requestLogger,
+          requestId,
+          startedAt
+        });
       }
       if (request.method === "POST" && url.pathname === "/v1/completions") {
-        return await handleCompletions(client, request);
+        return finishResponse(await handleCompletions(client, request, requestLogger), {
+          logger: requestLogger,
+          requestId,
+          startedAt
+        });
       }
       if (request.method === "POST" && url.pathname === "/v1/responses") {
-        return await handleResponses(client, request);
+        return finishResponse(await handleResponses(client, request, requestLogger), {
+          logger: requestLogger,
+          requestId,
+          startedAt
+        });
       }
-      return jsonError(404, "not_found", `No route for ${request.method} ${url.pathname}.`);
+      return finishResponse(
+        jsonError(404, "not_found", `No route for ${request.method} ${url.pathname}.`),
+        { logger: requestLogger, requestId, startedAt }
+      );
     } catch (error) {
       if (error instanceof CopilotAuthError) {
-        return jsonError(401, "copilot_auth_error", error.message);
+        requestLogger.warn(
+          { err: errorDetails(error), event: "copilot.auth.missing" },
+          "copilot auth failed"
+        );
+        return finishResponse(jsonError(401, "copilot_auth_error", error.message), {
+          logger: requestLogger,
+          requestId,
+          startedAt
+        });
       }
-      return jsonError(500, "internal_error", errorMessage2(error));
+      const message = errorMessage(error);
+      if (message === INVALID_JSON_MESSAGE) {
+        requestLogger.warn(
+          { err: errorDetails(error), event: "http.request.failed" },
+          "request body was invalid json"
+        );
+      } else {
+        requestLogger.error(
+          { err: errorDetails(error), event: "http.request.failed" },
+          "request failed"
+        );
+      }
+      return finishResponse(jsonError(500, "internal_error", message), {
+        logger: requestLogger,
+        requestId,
+        startedAt
+      });
     }
   };
 }
@@ -932,35 +1087,53 @@ function startHoopilotServer(options = {}) {
     url: `http://${host}:${server.port}`
   };
 }
-async function handleModels(client, signal) {
+async function handleModels(client, signal, logger) {
   const upstream = await client.models(signal);
   if (!upstream.ok) {
+    if (isUpstreamAuthStatus(upstream.status)) {
+      return proxyError(upstream, logger);
+    }
+    logger.warn(
+      {
+        event: "copilot.models.fallback",
+        upstreamPath: "/models",
+        upstreamStatus: upstream.status
+      },
+      "falling back to built-in model list"
+    );
     return jsonResponse({ data: fallbackModels(), object: "list" });
   }
+  logUpstreamSuccess(logger, "/models", upstream.status);
   return jsonResponse(normalizeModelsResponse(await upstream.json()));
 }
-async function handleChatCompletions(client, request) {
+async function handleChatCompletions(client, request, logger) {
   const upstream = await client.forwardChatCompletions(await request.text(), request.signal);
+  if (!upstream.ok) {
+    return proxyError(upstream, logger);
+  }
+  logUpstreamSuccess(logger, "/chat/completions", upstream.status);
   return proxyResponse(upstream);
 }
-async function handleCompletions(client, request) {
+async function handleCompletions(client, request, logger) {
   const body = await readJson(request);
   const upstream = await client.chatCompletions(
     completionsRequestToChatCompletion(body),
     request.signal
   );
   if (!upstream.ok) {
-    return proxyError(upstream);
+    return proxyError(upstream, logger);
   }
+  logUpstreamSuccess(logger, "/chat/completions", upstream.status);
   return jsonResponse(chatCompletionToCompletion(await upstream.json()));
 }
-async function handleResponses(client, request) {
+async function handleResponses(client, request, logger) {
   const body = await readJson(request);
   const chatRequest = responsesRequestToChatCompletion(body);
   const upstream = await client.chatCompletions(chatRequest, request.signal);
   if (!upstream.ok) {
-    return proxyError(upstream);
+    return proxyError(upstream, logger);
   }
+  logUpstreamSuccess(logger, "/chat/completions", upstream.status);
   if (body.stream === true && upstream.body) {
     return new Response(
       responsesStreamFromChatStream(upstream.body, {
@@ -978,8 +1151,19 @@ async function handleResponses(client, request) {
   }
   return jsonResponse(chatCompletionToResponse(await upstream.json()));
 }
-async function proxyError(upstream) {
+async function proxyError(upstream, logger) {
   const text = await upstream.text();
+  if (isUpstreamAuthStatus(upstream.status)) {
+    logger.warn(
+      { event: "copilot.auth.rejected", upstreamStatus: upstream.status },
+      "copilot rejected credential or account access"
+    );
+    return jsonError(401, "copilot_auth_error", upstreamAuthMessage(text || upstream.statusText));
+  }
+  logger.warn(
+    { event: "copilot.request.failed", upstreamStatus: upstream.status },
+    "copilot upstream request failed"
+  );
   return jsonError(upstream.status, "copilot_error", text || upstream.statusText);
 }
 function proxyResponse(upstream) {
@@ -1001,7 +1185,7 @@ async function readJson(request) {
     const value = await request.json();
     return value && typeof value === "object" && !Array.isArray(value) ? value : {};
   } catch {
-    throw new Error("Request body must be valid JSON.");
+    throw new Error(INVALID_JSON_MESSAGE);
   }
 }
 function jsonResponse(body, status = 200) {
@@ -1040,27 +1224,134 @@ function isAuthorized(request, apiKey) {
   const bearer = authorization.match(/^Bearer\s+(.+)$/i)?.[1];
   return bearer === apiKey || request.headers.get("x-api-key") === apiKey;
 }
+function isUpstreamAuthStatus(status) {
+  return status === 401 || status === 403;
+}
+function upstreamAuthMessage(message) {
+  return `GitHub Copilot rejected the credential or account access: ${message}`;
+}
 function isLoopbackHost(host) {
   return host === "localhost" || host === "127.0.0.1" || host === "::1";
 }
-function errorMessage2(error) {
+function errorMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
+function serverLogger(options) {
+  if (options.logger) {
+    return options.logger.child({ component: "server" });
+  }
+  if (shouldCreateLogger(options)) {
+    return createHoopilotLogger({
+      env: options.env,
+      format: options.logFormat,
+      level: options.logLevel
+    }).child({ component: "server" });
+  }
+  return noopLogger;
+}
+function finishResponse(response, options) {
+  const withRequestId = responseWithRequestId(response, options.requestId);
+  logRequestCompleted(options.logger, withRequestId, options.startedAt);
+  return withRequestId;
+}
+function responseWithRequestId(response, requestId) {
+  const headers = new Headers(response.headers);
+  headers.set("x-request-id", requestId);
+  return new Response(response.body, {
+    headers,
+    status: response.status,
+    statusText: response.statusText
+  });
+}
+function logRequestCompleted(logger, response, startedAt) {
+  const fields = {
+    durationMs: Math.round((performance.now() - startedAt) * 100) / 100,
+    event: "http.request.completed",
+    status: response.status,
+    stream: isStreamingResponse(response)
+  };
+  if (response.status >= 500) {
+    logger.error(fields, "request completed with server error");
+    return;
+  }
+  if (response.status >= 400) {
+    logger.warn(fields, "request completed with client error");
+    return;
+  }
+  logger.info(fields, "request completed");
+}
+function requestIdFor(request) {
+  const existing = request.headers.get("x-request-id")?.trim();
+  return existing || crypto.randomUUID();
+}
+function routeFor(method, path) {
+  if (method === "OPTIONS") {
+    return "cors.preflight";
+  }
+  if (method === "GET" && (path === "/" || path === "/healthz")) {
+    return "health";
+  }
+  if (method === "GET" && path === "/v1/models") {
+    return "models";
+  }
+  if (method === "POST" && path === "/v1/chat/completions") {
+    return "chat_completions";
+  }
+  if (method === "POST" && path === "/v1/completions") {
+    return "completions";
+  }
+  if (method === "POST" && path === "/v1/responses") {
+    return "responses";
+  }
+  return "not_found";
+}
+function isStreamingResponse(response) {
+  return response.headers.get("content-type")?.includes("text/event-stream") ?? false;
+}
+function logUpstreamSuccess(logger, upstreamPath, status) {
+  logger.debug(
+    {
+      event: "copilot.request.completed",
+      upstreamPath,
+      upstreamStatus: status
+    },
+    "copilot upstream request completed"
+  );
+}
+function errorDetails(error) {
+  if (error instanceof Error) {
+    return {
+      message: error.message,
+      name: error.name,
+      stack: error.stack
+    };
+  }
+  return { message: String(error) };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CopilotAuth,
   CopilotAuthError,
   CopilotClient,
+  DEFAULT_LOG_FORMAT,
+  DEFAULT_LOG_LEVEL,
   DEFAULT_MODEL,
+  authStorePath,
   chatCompletionToCompletion,
   chatCompletionToResponse,
   completionsRequestToChatCompletion,
   createHoopilotHandler,
+  createHoopilotLogger,
   fallbackModels,
+  githubCopilotDeviceLogin,
+  noopLogger,
   normalizeModelsResponse,
+  parseLogFormat,
+  parseLogLevel,
+  readStoredCopilotAuth,
   responsesRequestToChatCompletion,
   responsesStreamFromChatStream,
-  splitCommand,
-  startHoopilotServer
+  startHoopilotServer,
+  writeStoredCopilotAuth
 });
 //# sourceMappingURL=index.cjs.map