@thejeetsingh/kalcode 2.0.0 → 2.1.0

package/README.md

@@ -62,7 +62,6 @@ Run the backend proxy with your NVIDIA key on a server you control:
 
 ```bash
 export NVIDIA_NIM_KEY="your-real-provider-key"
-export KALCODE_PROXY_TOKEN="choose-a-long-random-token"
 export PORT=8787
 bun run proxy
 ```
@@ -71,7 +70,6 @@ Client users run `kalcode` with proxy settings (no NVIDIA key needed on client):
 
 ```bash
 export KALCODE_PROXY_URL="https://your-proxy-domain"
-export KALCODE_PROXY_TOKEN="same-token-as-server"
 kalcode
 ```
 
@@ -103,13 +101,11 @@ This repo now includes Vercel serverless endpoints:
 ### 2) Set Vercel environment variables
 
 - `NVIDIA_NIM_KEY` = your provider key (server-only)
-- `KALCODE_PROXY_TOKEN` = long random token for client auth
 
 ### 3) Configure clients
 
 ```bash
 export KALCODE_PROXY_URL="https://<your-vercel-project>.vercel.app"
-export KALCODE_PROXY_TOKEN="<same-token-as-vercel-env>"
 kalcode
 ```
 

package/api/health.ts

@@ -1,10 +1,8 @@
-export const runtime = "edge";
+export const config = { runtime: "edge" };
 
-export default async function handler(): Promise<Response> {
+export default function handler(_req: Request): Response {
   return new Response(JSON.stringify({ ok: true }), {
     status: 200,
-    headers: {
-      "Content-Type": "application/json",
-    },
+    headers: { "Content-Type": "application/json" },
   });
 }

package/api/v1/chat/completions.ts

@@ -1,41 +1,25 @@
 const API_URL = "https://integrate.api.nvidia.com/v1/chat/completions";
 
-export const runtime = "edge";
+export const config = { runtime: "edge" };
 
 function json(status: number, payload: Record<string, unknown>): Response {
   return new Response(JSON.stringify(payload), {
     status,
-    headers: {
-      "Content-Type": "application/json",
-    },
+    headers: { "Content-Type": "application/json" },
   });
 }
 
-function getBearerToken(req: Request): string {
-  const auth = req.headers.get("authorization") || "";
-  const m = auth.match(/^Bearer\s+(.+)$/i);
-  return m?.[1]?.trim() || "";
-}
-
 export default async function handler(req: Request): Promise<Response> {
   if (req.method !== "POST") {
     return json(405, { error: { message: "Method not allowed." } });
   }
 
   const serverNimKey = process.env.NVIDIA_NIM_KEY || "";
-  const requiredProxyToken = process.env.KALCODE_PROXY_TOKEN || "";
 
   if (!serverNimKey) {
     return json(500, { error: { message: "Server missing NVIDIA_NIM_KEY." } });
   }
 
-  if (requiredProxyToken) {
-    const incoming = getBearerToken(req);
-    if (!incoming || incoming !== requiredProxyToken) {
-      return json(401, { error: { message: "Unauthorized." } });
-    }
-  }
-
   const body = await req.text();
   const upstream = await fetch(API_URL, {
     method: "POST",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thejeetsingh/kalcode",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "description": "CLI coding agent powered by NVIDIA NIM",
   "author": "Jeet Singh",
   "license": "MIT",

package/src/api/client.ts

@@ -1,4 +1,4 @@
-import { API_URL, RATE_LIMIT_MAX, RATE_LIMIT_WINDOW, MAX_RETRIES, RETRY_BASE_DELAY } from "../constants.js";
+import { API_URL, DEFAULT_PROXY_URL, RATE_LIMIT_MAX, RATE_LIMIT_WINDOW, MAX_RETRIES, RETRY_BASE_DELAY } from "../constants.js";
 import type { Message, StreamDelta, ToolDefinition } from "../types.js";
 import { parseSSEStream } from "./stream-parser.js";
 
@@ -28,27 +28,18 @@ export async function* streamChat(
   tools?: ToolDefinition[],
   onRetry?: (attempt: number, waitSec: number) => void
 ): AsyncGenerator<StreamDelta> {
-  const proxyUrl = (process.env.KALCODE_PROXY_URL || "").trim();
-  const proxyToken = (process.env.KALCODE_PROXY_TOKEN || "").trim();
+  const explicitProxy = (process.env.KALCODE_PROXY_URL || "").trim();
+  // If no API key and no explicit proxy, auto-use the public Vercel proxy
+  const proxyUrl = explicitProxy || (!apiKey ? DEFAULT_PROXY_URL : "");
   const targetUrl = proxyUrl
     ? `${proxyUrl.replace(/\/+$/, "")}/v1/chat/completions`
     : API_URL;
-  const authToken = proxyUrl ? proxyToken : apiKey;
+  const authToken = apiKey;
 
-  if (proxyUrl && !proxyToken) {
+  if (!proxyUrl && !authToken) {
     yield {
       type: "error",
-      error: "KALCODE_PROXY_URL is set but KALCODE_PROXY_TOKEN is missing.",
-    };
-    return;
-  }
-
-  if (!authToken) {
-    yield {
-      type: "error",
-      error: proxyUrl
-        ? "Missing proxy auth token."
-        : "Missing NVIDIA API key.",
+      error: "Missing NVIDIA API key.",
     };
     return;
   }
@@ -71,10 +62,14 @@ export async function* streamChat(
 
     const response = await fetch(targetUrl, {
       method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${authToken}`,
-      },
+      headers: proxyUrl
+        ? {
+            "Content-Type": "application/json",
+          }
+        : {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${authToken}`,
+          },
       body: JSON.stringify(body),
     });
 

package/src/constants.ts

@@ -1,7 +1,10 @@
-export const VERSION = "2.0.0";
+export const VERSION = "2.1.0";
 
 export const API_URL = "https://integrate.api.nvidia.com/v1/chat/completions";
 
+/** Public proxy — used automatically when no API key is set */
+export const DEFAULT_PROXY_URL = "https://kalcode.vercel.app";
+
 export const DEFAULT_MODEL = "qwen/qwen3-coder-480b-a35b-instruct";
 
 export const AVAILABLE_MODELS: { id: string; name: string; params: string }[] = [

package/src/index.ts

@@ -41,7 +41,7 @@ const REPL_COMMANDS: { cmd: string; desc: string }[] = [
 
 export async function main(): Promise<void> {
   const { values, positionals } = parseArgs({
-    args: Bun.argv.slice(2),
+    args: process.argv.slice(2),
     options: {
       help: { type: "boolean", short: "h" },
       version: { type: "boolean", short: "v" },
@@ -88,9 +88,9 @@ export async function main(): Promise<void> {
   if (values["auto-accept"]) setPermissionLevel("auto");
   if (values.ask) setAskMode(true);
   const proxyUrl = (process.env.KALCODE_PROXY_URL || "").trim();
-  const proxyMode = proxyUrl.length > 0;
+  const proxyMode = proxyUrl.length > 0 || !config.apiKey;   // auto-proxy when no key
 
-  // API key check (skip when using proxy mode)
+  // API key check — skip when proxy will be used (explicit or auto-fallback)
   if (!proxyMode && !config.apiKey) {
     console.log("");
     console.log(chalk.yellow("  No API key found."));

package/src/proxy/server.ts

@@ -2,7 +2,6 @@ import { API_URL } from "../constants.js";
 
 const PORT = parseInt(process.env.PORT || "8787", 10);
 const HOST = process.env.HOST || "0.0.0.0";
-const PROXY_TOKEN = process.env.KALCODE_PROXY_TOKEN || "";
 const NVIDIA_NIM_KEY = process.env.NVIDIA_NIM_KEY || "";
 const RATE_LIMIT_PER_MIN = Math.max(
   1,
@@ -42,12 +41,6 @@ function isRateLimited(clientId: string): boolean {
   return false;
 }
 
-function getBearerToken(req: Request): string {
-  const auth = req.headers.get("authorization") || "";
-  const m = auth.match(/^Bearer\s+(.+)$/i);
-  return m?.[1]?.trim() || "";
-}
-
 async function proxyCompletions(req: Request): Promise<Response> {
   if (!NVIDIA_NIM_KEY) {
     return json(500, {
@@ -57,17 +50,6 @@ async function proxyCompletions(req: Request): Promise<Response> {
     });
   }
 
-  if (PROXY_TOKEN) {
-    const incomingToken = getBearerToken(req);
-    if (!incomingToken || incomingToken !== PROXY_TOKEN) {
-      return json(401, {
-        error: {
-          message: "Unauthorized. Invalid proxy token.",
-        },
-      });
-    }
-  }
-
   const clientId = getClientId(req);
   if (isRateLimited(clientId)) {
     return json(429, {

package/tsconfig.json

@@ -11,5 +11,6 @@
     "rootDir": ".",
     "types": ["bun"]
   },
-  "include": ["src/**/*", "bin/**/*", "api/**/*"]
+  "include": ["src/**/*", "bin/**/*"],
+  "exclude": ["api"]
 }

package/vercel.json

@@ -1,4 +1,5 @@
 {
+  "framework": null,
   "rewrites": [
     {
       "source": "/v1/chat/completions",