@juspay/neurolink 12.48.2 → 12.49.0

package/dist/cli/commands/serve.d.ts

@@ -9,9 +9,6 @@
  *   neurolink serve status
  */
 import type { CommandModule } from "yargs";
-/**
- * Serve CLI command factory
- */
 export declare class ServeCommandFactory {
     /**
      * Create the main serve command

package/dist/cli/commands/serve.js

@@ -134,6 +134,50 @@ function createFileWatcher(onRestart, quiet) {
 /**
  * Serve CLI command factory
  */
+/** A Node `http.Server` (or `https.Server`): it can take an `upgrade` listener. */
+function isNodeHttpServer(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        typeof value.on === "function" &&
+        typeof value.listen === "function");
+}
+/**
+ * Live transcription streams over a WebSocket upgrade, which the HTTP
+ * adapters cannot route; it attaches to the Node server once it listens, on
+ * the first start and on every watch-mode restart. Bun and Deno serve
+ * without one, and then the route is simply absent. Guarded by the same
+ * NEUROLINK_SERVER_API_KEY(s) as the HTTP routes.
+ */
+/** `--cors-origin` values, split on commas and trimmed; `undefined` when none were given. */
+function corsOriginsFromArgv(values) {
+    if (!values || values.length === 0) {
+        return undefined;
+    }
+    const origins = values
+        .flatMap((value) => String(value).split(","))
+        .map((origin) => origin.trim())
+        .filter((origin) => origin.length > 0);
+    return origins.length > 0 ? origins : undefined;
+}
+async function attachTranscriptionWebSocket(server, neurolink, serverConfig) {
+    const native = server.getNativeServer?.();
+    if (!isNodeHttpServer(native)) {
+        return;
+    }
+    const { attachTranscribeWebSocket } = await import("../../server/websocket/transcribeWebSocket.js");
+    const apiKeys = readServerApiKeys();
+    // The same origin allow-list as the HTTP routes: with CORS on and a list
+    // that is not "*", a page from an unlisted origin cannot open the stream.
+    const origins = serverConfig.cors?.origins;
+    const allowedOrigins = serverConfig.cors?.enabled !== false && origins && !origins.includes("*")
+        ? origins
+        : undefined;
+    await attachTranscribeWebSocket(native, neurolink, {
+        ...(apiKeys.length > 0 ? { authToken: apiKeys } : {}),
+        ...(allowedOrigins ? { allowedOrigins } : {}),
+    });
+    logger.debug("[serve] transcription WebSocket attached at /v1/audio/transcriptions/stream");
+}
 export class ServeCommandFactory {
     /**
      * Create the main serve command
@@ -180,6 +224,13 @@ export class ServeCommandFactory {
                     .option("cors", {
                     type: "boolean",
                     description: "Enable CORS middleware (default: true)",
+                })
+                    .option("cors-origin", {
+                    type: "array",
+                    string: true,
+                    alias: "corsOrigin",
+                    description: "Browser origin allowed by CORS (repeat or comma-separate; '*' for any). " +
+                        "Default: none, so no web page can call the server cross-origin",
                 })
                     .option("rate-limit", {
                     type: "number",
@@ -351,6 +402,9 @@ export class ServeCommandFactory {
                 enabled: argv.cors !== undefined
                     ? argv.cors
                     : (fileConfig.cors?.enabled ?? defaultConfig.cors.enabled),
+                ...(corsOriginsFromArgv(argv.corsOrigin)
+                    ? { origins: corsOriginsFromArgv(argv.corsOrigin) }
+                    : {}),
             },
             rateLimit: {
                 ...defaultConfig.rateLimit,
@@ -366,7 +420,13 @@ export class ServeCommandFactory {
             },
             bodyParser: fileConfig.bodyParser,
             logging: fileConfig.logging,
-            timeout: fileConfig.timeout,
+            // Transcription of a long recording through a remote engine can take
+            // longer than the 30 s default, so the request timeout is also
+            // settable from the environment (milliseconds); the config file wins.
+            timeout: fileConfig.timeout ??
+                (Number(process.env.NEUROLINK_SERVER_TIMEOUT_MS) > 0
+                    ? Number(process.env.NEUROLINK_SERVER_TIMEOUT_MS)
+                    : undefined),
             enableMetrics: fileConfig.enableMetrics ?? true,
             enableSwagger: argv.swagger !== undefined
                 ? argv.swagger
@@ -394,6 +454,7 @@ export class ServeCommandFactory {
         }
         await withTimeout(serverRef.current.initialize(), 30000, new ServerStartError("Server initialization timed out after 30 seconds", undefined, opts.port, opts.host));
         await withTimeout(serverRef.current.start(), 30000, new ServerStartError("Server startup timed out after 30 seconds", undefined, opts.port, opts.host));
+        await attachTranscriptionWebSocket(serverRef.current, neurolink, opts.serverConfig);
         return serverRef;
     }
     /**
@@ -426,6 +487,11 @@ export class ServeCommandFactory {
         }
         const url = `http://${opts.host === "0.0.0.0" ? "localhost" : opts.host}:${opts.port}`;
         const corsEnabled = opts.argv.cors ?? opts.serverConfig.cors?.enabled ?? true;
+        // The origin list and the API key together decide whether any browser
+        // page may call this server; the banner says which case this is.
+        const corsOrigins = opts.serverConfig.cors?.origins ?? [];
+        const corsWildcard = corsEnabled && corsOrigins.includes("*");
+        const corsNoOrigins = corsEnabled && corsOrigins.length === 0;
         const rateLimitValue = opts.argv.rateLimit ?? opts.serverConfig.rateLimit?.maxRequests ?? 100;
         const rateLimitEnabled = rateLimitValue > 0;
         const swaggerEnabled = opts.argv.swagger ?? opts.serverConfig.enableSwagger ?? false;
@@ -436,6 +502,8 @@ export class ServeCommandFactory {
             pid: state.pid,
             configFile: opts.argv.config,
             corsEnabled,
+            corsWildcard,
+            corsNoOrigins,
             rateLimitEnabled,
             rateLimitValue,
             swaggerEnabled,
@@ -461,7 +529,16 @@ export class ServeCommandFactory {
         }
         logger.always("");
         logger.always(chalk.bold("Middleware:"));
-        logger.always(`  CORS:        ${info.corsEnabled ? chalk.green("enabled") : chalk.yellow("disabled")}`);
+        logger.always(`  CORS:        ${!info.corsEnabled
+            ? chalk.yellow("disabled")
+            : info.corsWildcard
+                ? info.authEnabled
+                    ? chalk.green("enabled (any origin; API key required)")
+                    : chalk.yellow("enabled for ANY origin and no API key — any web page can call this server; set " +
+                        SERVER_API_KEY_ENV)
+                : info.corsNoOrigins
+                    ? chalk.yellow("enabled, no origins listed — browsers cannot call this server; pass --cors-origin or set cors.origins")
+                    : chalk.green("enabled (listed origins)")}`);
         logger.always(`  Rate Limit:  ${info.rateLimitEnabled ? chalk.green(`enabled (${info.rateLimitValue} req/15min)`) : chalk.yellow("disabled")}`);
         logger.always(`  Swagger:     ${info.swaggerEnabled ? chalk.green("enabled") : chalk.yellow("disabled")}`);
         if (info.watchEnabled) {
@@ -513,7 +590,8 @@ export class ServeCommandFactory {
                 const timestamp = Date.now();
                 const { createServer: createNewServer, registerAllRoutes: registerNewRoutes, } = await import(`../../server/index.js?t=${timestamp}`);
                 // Create new server
-                const newServer = await createNewServer(new NeuroLink(), {
+                const newNeurolink = new NeuroLink();
+                const newServer = await createNewServer(newNeurolink, {
                     framework: ctx.framework,
                     config: ctx.serverConfig,
                 });
@@ -522,6 +600,10 @@ export class ServeCommandFactory {
                 // Initialize and start with timeouts
                 await withTimeout(newServer.initialize(), 30000, new ServerStartError("Server initialization timed out during restart", undefined, ctx.port, ctx.host));
                 await withTimeout(newServer.start(), 30000, new ServerStartError("Server startup timed out during restart", undefined, ctx.port, ctx.host));
+                // The upgrade handler lives on the old adapter's http.Server; the
+                // restarted one needs its own, or the stream route is gone after the
+                // first file change.
+                await attachTranscriptionWebSocket(newServer, newNeurolink, ctx.serverConfig);
                 // Update the reference so signal handlers use the new server instance
                 ctx.serverRef.current = newServer;
                 logger.always(chalk.green("Server restarted successfully"));

package/dist/cli/commands/transcribe.d.ts

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+/**
+ * NeuroLink CLI Transcribe Command
+ *
+ * Calls `NeuroLink.transcribe()` — audio in, text out — or, with `--stream`,
+ * `NeuroLink.transcribeStream()` over the file decoded to 16 kHz mono PCM16.
+ * See src/lib/types/transcribe.ts for the full vocabulary (dictionary,
+ * correction, second opinion, fallback).
+ *
+ * Credentials are env-only here, exactly as every other CLI command: each STT
+ * handler reads its own settings, and `NEUROLINK_STT_PROVIDER`,
+ * `NEUROLINK_STT_MODEL` and `NEUROLINK_STT_LANGUAGE` pick the defaults. With
+ * nothing configured the built-in local engine (Whistle) is used.
+ */
+import type { CommandModule } from "yargs";
+import type { CliTranscribeArgs } from "../../types/index.js";
+export declare const transcribeCommand: CommandModule<object, CliTranscribeArgs>;
+/**
+ * Create transcribe command factory for CLICommandFactory-style registration,
+ * matching the DecideCommandFactory pattern.
+ */
+export declare class TranscribeCommandFactory {
+    static createTranscribeCommand(): CommandModule;
+}