@openhoo/hoopilot 0.2.2

package/dist/cli.js

@@ -0,0 +1,1162 @@
+#!/usr/bin/env bun
+
+// src/auth.ts
+import { execFileSync } from "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 REFRESH_SKEW_MS = 6e4;
+var defaultLogger = {
+  info: () => void 0,
+  warn: () => void 0,
+  error: () => void 0
+};
+var CopilotAuthError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CopilotAuthError";
+  }
+};
+var CopilotAuth = class {
+  #authMode;
+  #copilotApiBaseUrl;
+  #copilotToken;
+  #env;
+  #fetch;
+  #githubToken;
+  #githubTokenCommand;
+  #logger;
+  #tokenExchangeUrl;
+  #cachedAccess;
+  constructor(options = {}) {
+    this.#authMode = options.authMode ?? "auto";
+    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 ?? defaultLogger;
+    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 (this.#authMode === "copilot-token") {
+      if (!directCopilotToken) {
+        throw new CopilotAuthError("COPILOT_API_TOKEN or GITHUB_COPILOT_API_TOKEN is required.");
+      }
+      return this.#cacheAccess({
+        apiBaseUrl: this.#copilotApiBaseUrl,
+        expiresAtMs: Date.now() + 10 * 6e4,
+        source: "copilot-token",
+        token: directCopilotToken
+      });
+    }
+    if (directCopilotToken) {
+      return this.#cacheAccess({
+        apiBaseUrl: this.#copilotApiBaseUrl,
+        expiresAtMs: Date.now() + 10 * 6e4,
+        source: "copilot-token",
+        token: directCopilotToken
+      });
+    }
+    const githubToken = this.#resolveGithubToken();
+    if (!githubToken) {
+      throw new CopilotAuthError(
+        "No Copilot credential found. Set COPILOT_GITHUB_TOKEN, GITHUB_TOKEN, or sign in with gh auth login."
+      );
+    }
+    if (this.#authMode === "direct-github-token") {
+      return this.#cacheAccess({
+        apiBaseUrl: this.#copilotApiBaseUrl,
+        expiresAtMs: Date.now() + 10 * 6e4,
+        source: "direct-github-token",
+        token: githubToken
+      });
+    }
+    try {
+      const exchanged = await this.#exchangeGithubToken(githubToken);
+      return this.#cacheAccess(exchanged);
+    } catch (error) {
+      if (this.#authMode === "github-token") {
+        throw error;
+      }
+      this.#logger.warn(
+        `Copilot token exchange failed; falling back to direct GitHub token mode: ${errorMessage(error)}`
+      );
+      return this.#cacheAccess({
+        apiBaseUrl: this.#copilotApiBaseUrl,
+        expiresAtMs: Date.now() + 10 * 6e4,
+        source: "direct-github-token",
+        token: githubToken
+      });
+    }
+  }
+  #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 CopilotAuthError(
+        `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.#env.GH_TOKEN,
+      this.#env.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 = 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 errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/copilot.ts
+var CopilotClient = class {
+  #auth;
+  #fetch;
+  constructor(options = {}) {
+    this.#auth = new CopilotAuth(options);
+    this.#fetch = options.fetch ?? fetch;
+  }
+  async chatCompletions(body, signal) {
+    return this.fetchCopilot("/chat/completions", {
+      body: JSON.stringify(body),
+      headers: {
+        "content-type": "application/json"
+      },
+      method: "POST",
+      signal
+    });
+  }
+  async forwardChatCompletions(body, signal) {
+    return this.fetchCopilot("/chat/completions", {
+      body,
+      headers: {
+        "content-type": "application/json"
+      },
+      method: "POST",
+      signal
+    });
+  }
+  async models(signal) {
+    return this.fetchCopilot("/models", {
+      headers: {
+        accept: "application/json"
+      },
+      method: "GET",
+      signal
+    });
+  }
+  async fetchCopilot(path, init) {
+    const access = await this.#auth.getAccess();
+    const headers = new Headers(init.headers);
+    headers.set("accept", headers.get("accept") ?? "application/json");
+    headers.set("authorization", `Bearer ${access.token}`);
+    headers.set("copilot-integration-id", "vscode-chat");
+    headers.set("editor-plugin-version", "hoopilot/0.1.0");
+    headers.set("editor-version", "Hoopilot/0.1.0");
+    headers.set("openai-intent", "conversation-panel");
+    headers.set("user-agent", "hoopilot/0.1.0");
+    return this.#fetch(`${access.apiBaseUrl}${path}`, {
+      ...init,
+      headers
+    });
+  }
+};
+
+// src/openai.ts
+var DEFAULT_MODEL = "gpt-4.1";
+function responsesRequestToChatCompletion(request) {
+  const messages = [];
+  const instructions = contentToText(request.instructions);
+  if (instructions) {
+    messages.push({ content: instructions, role: "system" });
+  }
+  for (const message of inputToMessages(request.input)) {
+    messages.push(message);
+  }
+  return removeUndefined({
+    frequency_penalty: request.frequency_penalty,
+    max_tokens: request.max_output_tokens ?? request.max_tokens,
+    messages,
+    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,
+    seed: request.seed,
+    stream: request.stream === true,
+    temperature: request.temperature,
+    tool_choice: chatToolChoice(request.tool_choice),
+    tools: chatTools(request.tools),
+    top_p: request.top_p
+  });
+}
+function completionsRequestToChatCompletion(request) {
+  return removeUndefined({
+    max_tokens: request.max_tokens,
+    messages: [{ content: promptToText(request.prompt), role: "user" }],
+    model: contentToText(request.model) || DEFAULT_MODEL,
+    stream: request.stream === true,
+    temperature: request.temperature,
+    top_p: request.top_p
+  });
+}
+function chatCompletionToResponse(completion, responseId) {
+  const id = responseId ?? `resp_${randomId()}`;
+  const choice = firstChoice(completion);
+  const message = asRecord2(choice.message);
+  const model = contentToText(completion.model) || DEFAULT_MODEL;
+  const output = outputItemsFromMessage(message);
+  const usage = responseUsage(completion.usage);
+  return removeUndefined({
+    created_at: epochSeconds(),
+    error: null,
+    id,
+    incomplete_details: null,
+    instructions: null,
+    max_output_tokens: null,
+    metadata: {},
+    model,
+    object: "response",
+    output,
+    output_text: outputText(output),
+    parallel_tool_calls: true,
+    status: "completed",
+    temperature: null,
+    tool_choice: "auto",
+    tools: [],
+    top_p: null,
+    usage
+  });
+}
+function chatCompletionToCompletion(completion) {
+  const choice = firstChoice(completion);
+  const message = asRecord2(choice.message);
+  return removeUndefined({
+    choices: [
+      {
+        finish_reason: choice.finish_reason ?? "stop",
+        index: 0,
+        logprobs: null,
+        text: contentToText(message.content)
+      }
+    ],
+    created: completion.created ?? epochSeconds(),
+    id: completion.id ?? `cmpl_${randomId()}`,
+    model: completion.model ?? DEFAULT_MODEL,
+    object: "text_completion",
+    usage: completion.usage
+  });
+}
+function normalizeModelsResponse(upstream) {
+  const record = asRecord2(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) => ({
+    created: model.created ?? 0,
+    id: model.id,
+    object: "model",
+    owned_by: model.owned_by ?? "github-copilot"
+  }));
+  return {
+    data: models.length > 0 ? models : fallbackModels(),
+    object: "list"
+  };
+}
+function fallbackModels() {
+  return [
+    {
+      created: 0,
+      id: DEFAULT_MODEL,
+      object: "model",
+      owned_by: "github-copilot"
+    }
+  ];
+}
+function responsesStreamFromChatStream(chatStream, options) {
+  const encoder = new TextEncoder();
+  const decoder = new TextDecoder();
+  const responseId = options.responseId ?? `resp_${randomId()}`;
+  const messageId = `msg_${randomId()}`;
+  const createdAt = epochSeconds();
+  let buffer = "";
+  let text = "";
+  const tools = /* @__PURE__ */ new Map();
+  return new ReadableStream({
+    async start(controller) {
+      const enqueue = (event, data) => {
+        controller.enqueue(encoder.encode(encodeSse(event, data)));
+      };
+      enqueue("response.created", {
+        response: baseStreamResponse(responseId, options.model, createdAt, "in_progress", []),
+        type: "response.created"
+      });
+      enqueue("response.output_item.added", {
+        item: {
+          content: [],
+          id: messageId,
+          role: "assistant",
+          status: "in_progress",
+          type: "message"
+        },
+        output_index: 0,
+        type: "response.output_item.added"
+      });
+      enqueue("response.content_part.added", {
+        content_index: 0,
+        item_id: messageId,
+        output_index: 0,
+        part: {
+          annotations: [],
+          text: "",
+          type: "output_text"
+        },
+        type: "response.content_part.added"
+      });
+      const reader = chatStream.getReader();
+      try {
+        while (true) {
+          const result = await reader.read();
+          if (result.done) {
+            break;
+          }
+          buffer += decoder.decode(result.value, { stream: true });
+          const lines = buffer.split(/\r?\n/);
+          buffer = lines.pop() ?? "";
+          for (const line of lines) {
+            processChatSseLine(line, enqueue, tools, (delta) => {
+              text += delta;
+            });
+          }
+        }
+        if (buffer) {
+          processChatSseLine(buffer, enqueue, tools, (delta) => {
+            text += delta;
+          });
+        }
+        const output = streamOutputItems(messageId, text, [...tools.values()]);
+        enqueue("response.output_text.done", {
+          content_index: 0,
+          item_id: messageId,
+          output_index: 0,
+          text,
+          type: "response.output_text.done"
+        });
+        enqueue("response.content_part.done", {
+          content_index: 0,
+          item_id: messageId,
+          output_index: 0,
+          part: {
+            annotations: [],
+            text,
+            type: "output_text"
+          },
+          type: "response.content_part.done"
+        });
+        enqueue("response.output_item.done", {
+          item: output[0],
+          output_index: 0,
+          type: "response.output_item.done"
+        });
+        tools.forEach((tool, index) => {
+          const item = functionCallItem(tool);
+          const outputIndex = index + 1;
+          enqueue("response.output_item.added", {
+            item,
+            output_index: outputIndex,
+            type: "response.output_item.added"
+          });
+          enqueue("response.function_call_arguments.done", {
+            arguments: tool.arguments,
+            item_id: item.id,
+            output_index: outputIndex,
+            type: "response.function_call_arguments.done"
+          });
+          enqueue("response.output_item.done", {
+            item,
+            output_index: outputIndex,
+            type: "response.output_item.done"
+          });
+        });
+        enqueue("response.completed", {
+          response: baseStreamResponse(responseId, options.model, createdAt, "completed", output),
+          type: "response.completed"
+        });
+        enqueue("done", "[DONE]");
+        controller.close();
+      } catch (error) {
+        controller.error(error);
+      } finally {
+        reader.releaseLock();
+      }
+    }
+  });
+}
+function inputToMessages(input) {
+  if (typeof input === "string") {
+    return [{ content: input, role: "user" }];
+  }
+  if (!Array.isArray(input)) {
+    return [];
+  }
+  const messages = [];
+  for (const item of input) {
+    const record = asRecord2(item);
+    if (record.type === "function_call_output") {
+      messages.push({
+        content: contentToText(record.output),
+        role: "tool",
+        tool_call_id: contentToText(record.call_id)
+      });
+      continue;
+    }
+    if (record.type === "function_call") {
+      messages.push({
+        role: "assistant",
+        tool_calls: [
+          {
+            function: {
+              arguments: contentToText(record.arguments),
+              name: contentToText(record.name)
+            },
+            id: contentToText(record.call_id) || contentToText(record.id),
+            type: "function"
+          }
+        ]
+      });
+      continue;
+    }
+    const role = roleToChatRole(contentToText(record.role));
+    const content = chatMessageContent(record.content);
+    if (role && content !== void 0) {
+      messages.push({ content, role });
+    }
+  }
+  return messages;
+}
+function chatMessageContent(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  if (!Array.isArray(content)) {
+    return contentToText(content) || void 0;
+  }
+  const parts = [];
+  for (const part of content) {
+    const record = asRecord2(part);
+    const type = contentToText(record.type);
+    if (type === "input_text" || type === "output_text" || type === "text") {
+      parts.push({ text: contentToText(record.text), type: "text" });
+    }
+    if (type === "input_image") {
+      const imageUrl = contentToText(record.image_url);
+      if (imageUrl) {
+        parts.push({ image_url: { url: imageUrl }, type: "image_url" });
+      }
+    }
+  }
+  if (parts.length === 0) {
+    return void 0;
+  }
+  if (parts.every((part) => part.type === "text")) {
+    return parts.map((part) => contentToText(part.text)).join("\n");
+  }
+  return parts;
+}
+function promptToText(prompt) {
+  if (Array.isArray(prompt)) {
+    return prompt.map((item) => contentToText(item)).join("\n");
+  }
+  return contentToText(prompt);
+}
+function contentToText(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  if (typeof content === "number" || typeof content === "boolean") {
+    return String(content);
+  }
+  if (Array.isArray(content)) {
+    return content.map((item) => contentToText(item)).filter(Boolean).join("\n");
+  }
+  if (content && typeof content === "object") {
+    const record = content;
+    if (typeof record.text === "string") {
+      return record.text;
+    }
+    if (typeof record.output_text === "string") {
+      return record.output_text;
+    }
+    return JSON.stringify(content);
+  }
+  return "";
+}
+function roleToChatRole(role) {
+  if (role === "assistant" || role === "developer" || role === "system" || role === "tool") {
+    return role === "developer" ? "system" : role;
+  }
+  return "user";
+}
+function chatTools(tools) {
+  if (!Array.isArray(tools)) {
+    return void 0;
+  }
+  const converted = tools.map((tool) => asRecord2(tool)).filter((tool) => tool.type === "function").map((tool) => ({
+    function: removeUndefined({
+      description: tool.description,
+      name: tool.name,
+      parameters: tool.parameters,
+      strict: tool.strict
+    }),
+    type: "function"
+  }));
+  return converted.length > 0 ? converted : void 0;
+}
+function chatToolChoice(toolChoice) {
+  if (typeof toolChoice === "string" || toolChoice === void 0) {
+    return toolChoice;
+  }
+  const record = asRecord2(toolChoice);
+  if (record.type === "function" && typeof record.name === "string") {
+    return { function: { name: record.name }, type: "function" };
+  }
+  return toolChoice;
+}
+function outputItemsFromMessage(message) {
+  const output = [];
+  const text = contentToText(message.content);
+  if (text) {
+    output.push(messageOutputItem(text));
+  }
+  const toolCalls = Array.isArray(message.tool_calls) ? message.tool_calls : [];
+  for (const toolCall of toolCalls) {
+    const record = asRecord2(toolCall);
+    const fn = asRecord2(record.function);
+    output.push(
+      functionCallItem({
+        arguments: contentToText(fn.arguments),
+        id: contentToText(record.id) || `call_${randomId()}`,
+        index: output.length,
+        name: contentToText(fn.name)
+      })
+    );
+  }
+  return output;
+}
+function messageOutputItem(text, id = `msg_${randomId()}`) {
+  return {
+    content: [
+      {
+        annotations: [],
+        text,
+        type: "output_text"
+      }
+    ],
+    id,
+    role: "assistant",
+    status: "completed",
+    type: "message"
+  };
+}
+function functionCallItem(tool) {
+  return {
+    arguments: tool.arguments,
+    call_id: tool.id,
+    id: `fc_${randomId()}`,
+    name: tool.name,
+    status: "completed",
+    type: "function_call"
+  };
+}
+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("");
+}
+function responseUsage(usage) {
+  const record = asRecord2(usage);
+  if (Object.keys(record).length === 0) {
+    return null;
+  }
+  return removeUndefined({
+    input_tokens: record.prompt_tokens,
+    input_tokens_details: record.prompt_tokens_details,
+    output_tokens: record.completion_tokens,
+    output_tokens_details: record.completion_tokens_details,
+    total_tokens: record.total_tokens
+  });
+}
+function firstChoice(completion) {
+  const choices = Array.isArray(completion.choices) ? completion.choices : [];
+  return asRecord2(choices[0]);
+}
+function processChatSseLine(line, enqueue, tools, appendText) {
+  const trimmed = line.trim();
+  if (!trimmed.startsWith("data:")) {
+    return;
+  }
+  const data = trimmed.slice("data:".length).trim();
+  if (!data || data === "[DONE]") {
+    return;
+  }
+  const parsed = parseJson(data);
+  if (!parsed) {
+    return;
+  }
+  const choice = firstChoice(parsed);
+  const delta = asRecord2(choice.delta);
+  const content = contentToText(delta.content);
+  if (content) {
+    appendText(content);
+    enqueue("response.output_text.delta", {
+      content_index: 0,
+      delta: content,
+      item_id: "",
+      output_index: 0,
+      type: "response.output_text.delta"
+    });
+  }
+  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 index = typeof record.index === "number" ? record.index : tools.size;
+    const existing = tools.get(index) ?? {
+      arguments: "",
+      id: contentToText(record.id) || `call_${randomId()}`,
+      index,
+      name: ""
+    };
+    existing.id = contentToText(record.id) || existing.id;
+    existing.name += contentToText(fn.name);
+    existing.arguments += contentToText(fn.arguments);
+    tools.set(index, existing);
+  }
+}
+function streamOutputItems(messageId, text, tools) {
+  return [messageOutputItem(text, messageId), ...tools.map((tool) => functionCallItem(tool))];
+}
+function baseStreamResponse(id, model, createdAt, status, output) {
+  return {
+    created_at: createdAt,
+    error: null,
+    id,
+    incomplete_details: null,
+    instructions: null,
+    max_output_tokens: null,
+    metadata: {},
+    model,
+    object: "response",
+    output,
+    parallel_tool_calls: true,
+    status,
+    temperature: null,
+    tool_choice: "auto",
+    tools: [],
+    top_p: null
+  };
+}
+function encodeSse(event, data) {
+  if (data === "[DONE]") {
+    return "data: [DONE]\n\n";
+  }
+  return `event: ${event}
+data: ${JSON.stringify(data)}
+
+`;
+}
+function parseJson(data) {
+  try {
+    return asRecord2(JSON.parse(data));
+  } catch {
+    return void 0;
+  }
+}
+function removeUndefined(record) {
+  return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== void 0));
+}
+function asRecord2(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function randomId() {
+  return crypto.randomUUID().replaceAll("-", "");
+}
+function epochSeconds() {
+  return Math.floor(Date.now() / 1e3);
+}
+
+// src/server.ts
+var DEFAULT_HOST = "127.0.0.1";
+var DEFAULT_PORT = 4141;
+function createHoopilotHandler(options = {}) {
+  const client = new CopilotClient(options);
+  const apiKey = options.apiKey ?? options.env?.HOOPILOT_API_KEY;
+  return async (request) => {
+    const url = new URL(request.url);
+    if (request.method === "OPTIONS") {
+      return new Response(null, { headers: corsHeaders() });
+    }
+    if (!isAuthorized(request, apiKey)) {
+      return jsonError(401, "invalid_api_key", "Invalid or missing Hoopilot API key.");
+    }
+    try {
+      if (request.method === "GET" && (url.pathname === "/" || url.pathname === "/healthz")) {
+        return jsonResponse({
+          name: "hoopilot",
+          object: "health",
+          status: "ok"
+        });
+      }
+      if (request.method === "GET" && url.pathname === "/v1/models") {
+        return await handleModels(client, request.signal);
+      }
+      if (request.method === "POST" && url.pathname === "/v1/chat/completions") {
+        return await handleChatCompletions(client, request);
+      }
+      if (request.method === "POST" && url.pathname === "/v1/completions") {
+        return await handleCompletions(client, request);
+      }
+      if (request.method === "POST" && url.pathname === "/v1/responses") {
+        return await handleResponses(client, request);
+      }
+      return jsonError(404, "not_found", `No route for ${request.method} ${url.pathname}.`);
+    } catch (error) {
+      if (error instanceof CopilotAuthError) {
+        return jsonError(401, "copilot_auth_error", error.message);
+      }
+      return jsonError(500, "internal_error", errorMessage2(error));
+    }
+  };
+}
+function startHoopilotServer(options = {}) {
+  const host = options.host ?? options.env?.HOST ?? DEFAULT_HOST;
+  const port = Number(options.port ?? options.env?.PORT ?? DEFAULT_PORT);
+  const apiKey = options.apiKey ?? options.env?.HOOPILOT_API_KEY;
+  const allowUnauthenticated = options.allowUnauthenticated ?? options.env?.HOOPILOT_ALLOW_UNAUTHENTICATED === "1";
+  if (!isLoopbackHost(host) && !apiKey && !allowUnauthenticated) {
+    throw new Error(
+      "Refusing to listen on a non-loopback host without HOOPILOT_API_KEY. Set an API key or pass --allow-unauthenticated."
+    );
+  }
+  const server = Bun.serve({
+    fetch: createHoopilotHandler({
+      ...options,
+      apiKey,
+      host,
+      port
+    }),
+    hostname: host,
+    port
+  });
+  return {
+    server,
+    url: `http://${host}:${server.port}`
+  };
+}
+async function handleModels(client, signal) {
+  const upstream = await client.models(signal);
+  if (!upstream.ok) {
+    return jsonResponse({ data: fallbackModels(), object: "list" });
+  }
+  return jsonResponse(normalizeModelsResponse(await upstream.json()));
+}
+async function handleChatCompletions(client, request) {
+  const upstream = await client.forwardChatCompletions(await request.text(), request.signal);
+  return proxyResponse(upstream);
+}
+async function handleCompletions(client, request) {
+  const body = await readJson(request);
+  const upstream = await client.chatCompletions(
+    completionsRequestToChatCompletion(body),
+    request.signal
+  );
+  if (!upstream.ok) {
+    return proxyError(upstream);
+  }
+  return jsonResponse(chatCompletionToCompletion(await upstream.json()));
+}
+async function handleResponses(client, request) {
+  const body = await readJson(request);
+  const chatRequest = responsesRequestToChatCompletion(body);
+  const upstream = await client.chatCompletions(chatRequest, request.signal);
+  if (!upstream.ok) {
+    return proxyError(upstream);
+  }
+  if (body.stream === true && upstream.body) {
+    return new Response(
+      responsesStreamFromChatStream(upstream.body, {
+        model: typeof chatRequest.model === "string" ? chatRequest.model : "gpt-4.1"
+      }),
+      {
+        headers: {
+          ...corsHeaders(),
+          "cache-control": "no-cache",
+          connection: "keep-alive",
+          "content-type": "text/event-stream; charset=utf-8"
+        }
+      }
+    );
+  }
+  return jsonResponse(chatCompletionToResponse(await upstream.json()));
+}
+async function proxyError(upstream) {
+  const text = await upstream.text();
+  return jsonError(upstream.status, "copilot_error", text || upstream.statusText);
+}
+function proxyResponse(upstream) {
+  const headers = new Headers(upstream.headers);
+  headers.delete("content-encoding");
+  headers.delete("content-length");
+  headers.delete("transfer-encoding");
+  for (const [key, value] of Object.entries(corsHeaders())) {
+    headers.set(key, value);
+  }
+  return new Response(upstream.body, {
+    headers,
+    status: upstream.status,
+    statusText: upstream.statusText
+  });
+}
+async function readJson(request) {
+  try {
+    const value = await request.json();
+    return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+  } catch {
+    throw new Error("Request body must be valid JSON.");
+  }
+}
+function jsonResponse(body, status = 200) {
+  return new Response(JSON.stringify(body), {
+    headers: {
+      ...corsHeaders(),
+      "content-type": "application/json; charset=utf-8"
+    },
+    status
+  });
+}
+function jsonError(status, code, message) {
+  return jsonResponse(
+    {
+      error: {
+        code,
+        message,
+        type: code
+      }
+    },
+    status
+  );
+}
+function corsHeaders() {
+  return {
+    "access-control-allow-headers": "authorization, content-type, x-api-key",
+    "access-control-allow-methods": "GET, POST, OPTIONS",
+    "access-control-allow-origin": "*"
+  };
+}
+function isAuthorized(request, apiKey) {
+  if (!apiKey) {
+    return true;
+  }
+  const authorization = request.headers.get("authorization") ?? "";
+  const bearer = authorization.match(/^Bearer\s+(.+)$/i)?.[1];
+  return bearer === apiKey || request.headers.get("x-api-key") === apiKey;
+}
+function isLoopbackHost(host) {
+  return host === "localhost" || host === "127.0.0.1" || host === "::1";
+}
+function errorMessage2(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/cli.ts
+async function main(argv = Bun.argv.slice(2)) {
+  const args = parseArgs(argv);
+  if (args.help) {
+    console.log(helpText(await packageVersion()));
+    return;
+  }
+  if (args.version) {
+    console.log(await packageVersion());
+    return;
+  }
+  const started = startHoopilotServer(args);
+  console.log(`hoopilot listening on ${started.url}`);
+  console.log(`OpenAI base URL: ${started.url}/v1`);
+  console.log("Use Ctrl+C to stop.");
+}
+function parseArgs(argv) {
+  const args = {};
+  const rest = [...argv];
+  if (rest[0] === "serve") {
+    rest.shift();
+  }
+  while (rest.length > 0) {
+    const arg = rest.shift();
+    if (!arg) {
+      continue;
+    }
+    if (arg === "--help" || arg === "-h") {
+      args.help = true;
+      continue;
+    }
+    if (arg === "--version" || arg === "-v") {
+      args.version = true;
+      continue;
+    }
+    if (arg === "--allow-unauthenticated") {
+      args.allowUnauthenticated = true;
+      continue;
+    }
+    if (arg === "--no-gh") {
+      args.githubTokenCommand = false;
+      continue;
+    }
+    const [name, inlineValue] = arg.split("=", 2);
+    const value = inlineValue ?? rest.shift();
+    if (!value) {
+      throw new Error(`Missing value for ${arg}.`);
+    }
+    switch (name) {
+      case "--api-key":
+        args.apiKey = value;
+        break;
+      case "--auth-mode":
+        args.authMode = parseAuthMode(value);
+        break;
+      case "--copilot-api-base-url":
+        args.copilotApiBaseUrl = value;
+        break;
+      case "--copilot-token":
+        args.copilotToken = value;
+        break;
+      case "--github-token":
+        args.githubToken = value;
+        break;
+      case "--github-token-command":
+        args.githubTokenCommand = value;
+        break;
+      case "--host":
+        args.host = value;
+        break;
+      case "--port":
+      case "-p":
+        args.port = Number(value);
+        if (!Number.isInteger(args.port) || args.port <= 0) {
+          throw new Error(`Invalid port: ${value}.`);
+        }
+        break;
+      default:
+        throw new Error(`Unknown option: ${name}.`);
+    }
+  }
+  return args;
+}
+function parseAuthMode(value) {
+  if (value === "auto" || value === "copilot-token" || value === "github-token" || value === "direct-github-token") {
+    return value;
+  }
+  throw new Error(`Invalid auth mode: ${value}.`);
+}
+async function packageVersion() {
+  try {
+    const manifest = await Bun.file(new URL("../package.json", import.meta.url)).json();
+    return typeof manifest.version === "string" ? manifest.version : "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+function helpText(version) {
+  return `hoopilot ${version}
+
+OpenAI-compatible proxy for GitHub Copilot.
+
+Usage:
+  hoopilot [serve] [options]
+  npx @openhoo/hoopilot [options]
+
+Options:
+  -p, --port <port>                 Port to listen on. Default: 4141
+      --host <host>                 Host to listen on. Default: 127.0.0.1
+      --api-key <key>               Require clients to send Authorization: Bearer <key>
+      --auth-mode <mode>            auto, github-token, direct-github-token, copilot-token
+      --github-token <token>        GitHub OAuth token for a Copilot account
+      --github-token-command <cmd>  Command used to read a GitHub token. Default: gh auth token
+      --copilot-token <token>       Short-lived Copilot API bearer token
+      --copilot-api-base-url <url>  Copilot API base URL override
+      --no-gh                       Do not try gh auth token
+      --allow-unauthenticated       Allow non-loopback bind without --api-key
+  -h, --help                        Show help
+  -v, --version                     Show version
+
+Environment:
+  HOOPILOT_API_KEY
+  COPILOT_GITHUB_TOKEN, GITHUB_TOKEN, GH_TOKEN
+  COPILOT_API_TOKEN, GITHUB_COPILOT_API_TOKEN
+  COPILOT_API_BASE_URL
+`;
+}
+if (import.meta.main) {
+  main().catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  });
+}
+export {
+  main,
+  parseArgs
+};
+//# sourceMappingURL=cli.js.map