feat: Implement streaming responses and dynamic port configuration

Author: ericc-ch

bun.lock

@@ -0,0 +1,112 @@
+# 🔌 get-port-please
+
+Get an available TCP port to listen
+
+[![npm version][npm-version-src]][npm-version-href]
+[![npm downloads][npm-downloads-src]][npm-downloads-href]
+[![License][license-src]][license-href]
+[![JSDocs][jsdocs-src]][jsdocs-href]
+
+## Usage
+
+Install package:
+
+```bash
+npm i get-port-please
+```
+
+```js
+// ESM
+import {
+  getPort,
+  checkPort,
+  getRandomPort,
+  waitForPort,
+} from "get-port-please";
+
+// CommonJS
+const {
+  getPort,
+  checkPort,
+  getRandomPort,
+  waitForPort,
+} = require("get-port-please");
+```
+
+```
+getPort(options: GetPortOptions): Promise<number>;
+checkPort(port: number, host?: string): Promise<number | false>
+waitForPort(port: number, options): Promise<number | false>
+```
+
+Try sequence is: port > ports > random
+
+## Options
+
+```ts
+interface GetPortOptions {
+  name?: string;
+
+  random?: boolean;
+  port?: number;
+  portRange?: [fromInclusive: number, toInclusive: number];
+  ports?: number[];
+  host?: string;
+
+  memoDir?: string;
+  memoName?: string;
+}
+```
+
+### `name`
+
+Unique name for port memorizing. Default is `default`.
+
+### `random`
+
+If enabled, `port` and `ports` will be ignored. Default is `false`.
+
+### `port`
+
+First port to check. Default is `process.env.PORT || 3000`
+
+### `ports`
+
+Extended ports to check.
+
+### `portRange`
+
+Extended port range to check.
+
+The range's start and end are **inclusive**, i.e. it is `[start, end]` in the mathematical notion.
+Reversed port ranges are not supported. If `start > end`, then an empty range will be returned.
+
+### `alternativePortRange`
+
+Alternative port range to check as fallback when none of the ports are available.
+
+The range's start and end are **inclusive**, i.e. it is `[start, end]` in the mathematical notion.
+Reversed port ranges are not supported. If `start > end`, then an empty range will be returned.
+
+The default range is `[3000, 3100]` (only when `port` is unspecified).
+
+### `host`
+
+The host to check. Default is `process.env.HOST` otherwise all available hosts will be checked.
+
+## License
+
+MIT
+
+<!-- Badges -->
+
+[npm-version-src]: https://img.shields.io/npm/v/get-port-please?style=flat&colorA=18181B&colorB=F0DB4F
+[npm-version-href]: https://npmjs.com/package/get-port-please
+[npm-downloads-src]: https://img.shields.io/npm/dm/get-port-please?style=flat&colorA=18181B&colorB=F0DB4F
+[npm-downloads-href]: https://npmjs.com/package/get-port-please
+[codecov-src]: https://img.shields.io/codecov/c/gh/unjs/get-port-please/main?style=flat&colorA=18181B&colorB=F0DB4F
+[codecov-href]: https://codecov.io/gh/unjs/get-port-please
+[license-src]: https://img.shields.io/github/license/unjs/get-port-please.svg?style=flat&colorA=18181B&colorB=F0DB4F
+[license-href]: https://github.com/unjs/get-port-please/blob/main/LICENSE
+[jsdocs-src]: https://img.shields.io/badge/jsDocs.io-reference-18181B?style=flat&colorA=18181B&colorB=F0DB4F
+[jsdocs-href]: https://www.jsdocs.io/package/get-port-please

docs/get-port-please.md

@@ -41,6 +41,7 @@
     "citty": "^0.1.6",
     "consola": "^3.4.0",
     "fetch-event-stream": "^0.1.5",
+    "get-port-please": "^3.1.2",
     "hono": "^4.7.2",
     "ofetch": "^1.4.1",
     "pathe": "^2.0.3",

package.json

@@ -0,0 +1,38 @@
+interface Config {
+  EMULATE_STREAMING: boolean
+  LOGGING_ENABLED: boolean
+  PORT: number
+  PORT_RANGE: [number, number]
+}
+
+const DEFAULT_CONFIG: Config = {
+  EMULATE_STREAMING: false,
+  LOGGING_ENABLED: false,
+  PORT: 4141,
+  PORT_RANGE: [4142, 4200],
+}
+
+export class ConfigManager {
+  private static instance: ConfigManager | null = null
+  private config: Config = DEFAULT_CONFIG
+
+  public static getInstance(): ConfigManager {
+    if (!ConfigManager.instance) {
+      ConfigManager.instance = new ConfigManager()
+    }
+    return ConfigManager.instance
+  }
+
+  getConfig(): Config {
+    return this.config
+  }
+
+  setConfig(newConfig: Partial<Config>): void {
+    this.config = {
+      ...this.config,
+      ...newConfig,
+    }
+  }
+}
+
+export const configManager = ConfigManager.getInstance()

src/lib/config.ts

@@ -1,7 +1,3 @@
-export const APP_CONFIG = {
-  EMULATE_STREAMING: false,
-  LOGGING_ENABLED: false,
-}
 
 // VSCode client ID
 const GITHUB_CLIENT_ID = "01ab8ac9400c4e429b23"

src/lib/constants.ts

@@ -2,7 +2,6 @@ import consola from "consola"
 import fs from "node:fs/promises"
 import { FetchError } from "ofetch"
 
-import { APP_CONFIG } from "~/lib/constants"
 import { PATHS } from "~/lib/paths"
 import { getGitHubUser } from "~/services/github/get-user/service"
 
@@ -90,18 +89,25 @@ async function logUser() {
   consola.info(`Logged in as ${JSON.stringify(user.login)}`)
 }
 
+import { configManager } from "./config"
+import { initializePort } from "./port"
+
 export async function initializeApp(
   options: Awaited<ReturnType<typeof getOptions>>,
 ) {
-  APP_CONFIG.EMULATE_STREAMING = options["emulate-streaming"]
-  APP_CONFIG.LOGGING_ENABLED = options.logs
+  configManager.setConfig({
+    EMULATE_STREAMING: options["emulate-streaming"],
+    LOGGING_ENABLED: options.logs,
+  })
+
+  // Get available port, trying the CLI option first
+  const port = await initializePort()
 
   // Initialize logger if enabled
   await initializeLogger()
 
   await initialize()
 
-  const port = parseInt(options.port, 10)
   const serverUrl = `http://localhost:${port}`
   consola.success(`Server started at ${serverUrl}`)
 

src/lib/initialization.ts

@@ -1,16 +1,18 @@
 import fs from "node:fs/promises"
 
-import { APP_CONFIG } from "~/lib/constants"
+import { configManager } from "~/lib/config"
 import { PATHS } from "~/lib/paths"
 
 export function initializeLogger() {
-  if (!APP_CONFIG.LOGGING_ENABLED) return
+  const config = configManager.getConfig()
+  if (!config.LOGGING_ENABLED) return
 
   return fs.mkdir(PATHS.LOG_PATH, { recursive: true })
 }
 
 export async function logToFile(type: string, message: string) {
-  if (!APP_CONFIG.LOGGING_ENABLED) return
+  const config = configManager.getConfig()
+  if (!config.LOGGING_ENABLED) return
 
   const timestamp = new Date().toISOString()
   await fs.appendFile(PATHS.LOG_FILE, `${timestamp} ${type}: ${message}\n`)

src/lib/logger.ts

@@ -0,0 +1,18 @@
+import { getPort } from "get-port-please"
+
+import { configManager } from "./config"
+
+export async function initializePort(): Promise<number> {
+  const config = configManager.getConfig()
+
+  const port = await getPort({
+    name: "copilot-api",
+    port: config.PORT,
+    portRange: config.PORT_RANGE,
+    random: false,
+  })
+
+  configManager.setConfig({ PORT: port })
+
+  return port
+}

src/lib/port.ts

@@ -1,52 +1,25 @@
 import type { Context } from "hono"
 
-import consola from "consola"
-import { streamSSE } from "hono/streaming"
+import { streamSSE, type SSEMessage } from "hono/streaming"
 
 import type { ChatCompletionsPayload } from "~/services/copilot/chat-completions/types"
 
-import { logToFile } from "~/lib/logger"
 import { chatCompletions } from "~/services/copilot/chat-completions/service"
+import { chatCompletionsStream } from "~/services/copilot/chat-completions/service-streaming"
 
-import { createContentChunk, createFinalChunk, segmentResponse } from "./utils"
-
-export async function handler(c: Context) {
+export async function handlerStreaming(c: Context) {
   const payload = await c.req.json<ChatCompletionsPayload>()
 
-  const loggedPayload = structuredClone(payload)
-  loggedPayload.messages = loggedPayload.messages.map((message) => ({
-    ...message,
-    content:
-      message.content.length > 100 ?
-        message.content.slice(0, 100 - 3) + "..."
-      : message.content,
-  }))
-
-  consola.info("Received request:", loggedPayload)
-  await logToFile("REQUEST", JSON.stringify(payload, null, 2))
-
-  const response = await chatCompletions(payload)
-  await logToFile("RESPONSE", JSON.stringify(response, null, 2))
-
   if (payload.stream) {
-    consola.info(`Response from Copilot: ${JSON.stringify(response)}`)
-
-    const segments = segmentResponse(response.choices[0].message.content)
-    const chunks = segments.map((segment) =>
-      createContentChunk(segment, response, payload.model),
-    )
-
-    chunks.push(createFinalChunk(response, payload.model))
+    const response = await chatCompletionsStream(payload)
 
     return streamSSE(c, async (stream) => {
-      for (const chunk of chunks) {
-        await stream.writeSSE({
-          data: JSON.stringify(chunk.data),
-        })
-        await stream.sleep(1) // Simulated latency
+      for await (const chunk of response) {
+        await stream.writeSSE(chunk as SSEMessage)
       }
     })
   }
 
+  const response = await chatCompletions(payload)
   return c.json(response)
 }