loren-code 0.1.0

package/.env.example

@@ -0,0 +1,14 @@
+# Copy to .env.local and fill in your real Ollama Cloud API keys.
+# The bridge rotates one key per upstream request.
+OLLAMA_API_KEYS=
+
+# Optional: override where the bridge listens
+# BRIDGE_HOST=127.0.0.1
+# BRIDGE_PORT=8788
+
+# Optional: Ollama cloud host
+# OLLAMA_UPSTREAM_BASE_URL=https://ollama.com
+
+# Alias map shown to Claude Code users. Left side = selectable model in Claude.
+# Right side = real Ollama Cloud model id.
+OLLAMA_MODEL_ALIASES={"ollama-free-auto":"gpt-oss:20b","ollama-free-fast":"gemma3:12b","ollama-free-tools":"qwen3:32b"}

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 LOREN CODE
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,153 @@
+# LOREN CODE
+
+Ollama Cloud model manager and local bridge for Claude Code, with dynamic model switching, API key rotation, and first-run bootstrap.
+
+## Features
+
+- Dynamic model switching without restarting the server
+- Live model list fetched from Ollama Cloud
+- API key add/remove/rotate commands
+- First-run setup for `.env.local` and `.runtime`
+- Local bridge on port `8788`
+- Claude Code wrapper support
+
+## Quick Start
+
+### Prerequisites
+
+- Node.js 18+
+- Ollama Cloud API key(s)
+
+### Clone And Run Locally
+
+```bash
+git clone https://github.com/lorenzune/loren-code.git
+cd loren-code
+npm install
+node scripts/loren.js help
+```
+
+If `.env.local` is missing, Loren creates it automatically from `.env.example`.
+You still need to add real `OLLAMA_API_KEYS`.
+
+### Install From npm
+
+```bash
+npm install -g loren-code
+loren help
+```
+
+The published package exposes `loren` via the `bin` field automatically.
+
+## Configuration
+
+Example `.env.local`:
+
+```bash
+BRIDGE_HOST=127.0.0.1
+BRIDGE_PORT=8788
+OLLAMA_API_KEYS=sk-key1,sk-key2
+OLLAMA_UPSTREAM_BASE_URL=https://ollama.com
+DEFAULT_MODEL_ALIAS=gpt-oss:20b
+OLLAMA_MODEL_ALIASES={"ollama-free-auto":"gpt-oss:20b","ollama-free-fast":"gemma3:12b"}
+```
+
+## Usage
+
+### CLI
+
+```bash
+loren help
+loren config:show
+loren status
+loren model:list
+loren model:set gpt-oss:20b
+loren model:refresh
+loren keys:list
+loren keys:add sk-your-new-key
+loren keys:remove 0
+loren keys:rotate
+```
+
+### Server
+
+```bash
+npm start
+```
+
+or:
+
+```bash
+loren start
+loren stop
+loren status
+```
+
+## Bridge Endpoints
+
+- `GET /health`
+- `GET /v1/models`
+- `GET /v1/models?refresh=true`
+- `POST /v1/refresh`
+- `POST /v1/messages`
+- `POST /v1/messages/count_tokens`
+- `GET /metrics`
+- `GET /dashboard`
+
+## Claude Code Integration
+
+1. Start the bridge.
+2. Point Claude Code to `http://127.0.0.1:8788`.
+3. Use `loren model:set` to switch model aliases.
+4. Use `loren model:refresh` to refresh the model list.
+
+## Troubleshooting
+
+### `Command not found: loren`
+
+Install the package globally:
+
+```bash
+npm install -g loren-code
+```
+
+If you are working from a local clone, use `node scripts/loren.js ...`.
+
+### `npm` blocked in PowerShell
+
+Use `npm.cmd` instead:
+
+```powershell
+npm.cmd run help
+```
+
+### Missing API keys
+
+Populate `OLLAMA_API_KEYS` in `.env.local`.
+
+### Port already in use
+
+Change `BRIDGE_PORT` in `.env.local`.
+
+## Project Structure
+
+```text
+loren-code/
+|- scripts/
+|  |- loren.js
+|  |- claude-wrapper.js
+|  `- install-claude-ollama.ps1
+|- src/
+|  |- bootstrap.js
+|  |- server.js
+|  |- config.js
+|  |- key-manager.js
+|  `- ...
+|- .env.example
+|- package.json
+`- README.md
+```
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "loren-code",
+  "version": "0.1.0",
+  "description": "Ollama Cloud Model Manager - Dynamic model switching, API key rotation, and real-time configuration updates",
+  "author": "lorenzune",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lorenzune/loren-code.git"
+  },
+  "homepage": "https://github.com/lorenzune/loren-code#readme",
+  "bugs": {
+    "url": "https://github.com/lorenzune/loren-code/issues"
+  },
+  "keywords": [
+    "ollama",
+    "ollama-cloud",
+    "claude",
+    "claude-code",
+    "ai",
+    "llm",
+    "model-manager",
+    "cli",
+    "bridge"
+  ],
+  "type": "module",
+  "main": "src/server.js",
+  "bin": {
+    "loren": "scripts/loren.js"
+  },
+  "files": [
+    "scripts/ClaudeWrapperLauncher.cs",
+    "scripts/claude-wrapper.js",
+    "scripts/install-claude-ollama.ps1",
+    "scripts/loren.js",
+    "scripts/uninstall-claude-ollama.ps1",
+    "src/*.js",
+    ".env.example",
+    "README.md"
+  ],
+  "scripts": {
+    "start": "node src/server.js",
+    "loren": "node scripts/loren.js",
+    "install:claude": "powershell -ExecutionPolicy Bypass -File scripts/install-claude-ollama.ps1",
+    "uninstall:claude": "powershell -ExecutionPolicy Bypass -File scripts/uninstall-claude-ollama.ps1",
+    "model:list": "node scripts/loren.js model:list",
+    "model:set": "node scripts/loren.js model:set",
+    "model:current": "node scripts/loren.js model:current",
+    "model:refresh": "node scripts/loren.js model:refresh",
+    "keys:list": "node scripts/loren.js keys:list",
+    "keys:add": "node scripts/loren.js keys:add",
+    "keys:remove": "node scripts/loren.js keys:remove",
+    "keys:rotate": "node scripts/loren.js keys:rotate",
+    "config:show": "node scripts/loren.js config:show",
+    "help": "node scripts/loren.js help",
+    "smoke": "node scripts/smoke-test.js",
+    "check:publish": "node scripts/publish-check.js",
+    "prepublishOnly": "npm test && npm run lint",
+    "test": "node scripts/publish-check.js",
+    "lint": "node -e \"console.log('No linter configured')\""
+  },
+  "dependencies": {
+    "node-cache": "^5.1.2",
+    "winston": "^3.19.0",
+    "zod": "^4.3.6"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/scripts/ClaudeWrapperLauncher.cs

@@ -0,0 +1,78 @@
+using System;
+using System.Diagnostics;
+using System.IO;
+
+internal static class ClaudeWrapperLauncher
+{
+    private static int Main(string[] args)
+    {
+        try
+        {
+            var launcherDir = AppDomain.CurrentDomain.BaseDirectory;
+            var wrapperScript = Path.Combine(launcherDir, "claude-wrapper.js");
+
+            if (!File.Exists(wrapperScript))
+            {
+                Console.Error.WriteLine("Missing wrapper script: " + wrapperScript);
+                return 1;
+            }
+
+            var parent = Directory.GetParent(launcherDir);
+            var workingDirectory = parent != null ? parent.FullName : launcherDir;
+
+            var psi = new ProcessStartInfo
+            {
+                FileName = "node.exe",
+                Arguments = Quote(wrapperScript) + BuildArgumentString(args),
+                UseShellExecute = false,
+                RedirectStandardInput = false,
+                RedirectStandardOutput = false,
+                RedirectStandardError = false,
+                WorkingDirectory = workingDirectory,
+            };
+
+            using (var process = Process.Start(psi))
+            {
+                if (process == null)
+                {
+                    Console.Error.WriteLine("Failed to start node.exe");
+                    return 1;
+                }
+
+                process.WaitForExit();
+                return process.ExitCode;
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.Error.WriteLine(ex.Message);
+            return 1;
+        }
+    }
+
+    private static string BuildArgumentString(string[] args)
+    {
+        if (args == null || args.Length == 0)
+        {
+            return string.Empty;
+        }
+
+        var pieces = new string[args.Length];
+        for (var i = 0; i < args.Length; i++)
+        {
+            pieces[i] = Quote(args[i]);
+        }
+
+        return " " + string.Join(" ", pieces);
+    }
+
+    private static string Quote(string value)
+    {
+        if (string.IsNullOrEmpty(value))
+        {
+            return "\"\"";
+        }
+
+        return "\"" + value.Replace("\\", "\\\\").Replace("\"", "\\\"") + "\"";
+    }
+}

package/scripts/claude-wrapper.js

@@ -0,0 +1,216 @@
+import { spawn } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+import { ensureEnvLocal, ensureRuntimeDir, getBridgeBaseUrl } from "../src/bootstrap.js";
+import { loadConfig } from "../src/config.js";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const repoRoot = path.resolve(__dirname, "..");
+const stateDir = path.join(repoRoot, ".runtime");
+const bridgePidPath = path.join(stateDir, "bridge.pid");
+const bridgeLogPath = path.join(stateDir, "bridge.log");
+const envFilePath = path.join(repoRoot, ".env.local");
+
+async function main() {
+  process.chdir(repoRoot);
+  ensureRuntimeDir(repoRoot);
+  ensureEnvLocal(repoRoot);
+  const bridgeConfig = loadConfig();
+  const bridgeBaseUrl = getBridgeBaseUrl(bridgeConfig);
+
+  const env = {
+    ...process.env,
+    ...loadEnvFile(envFilePath),
+    ANTHROPIC_BASE_URL: process.env.ANTHROPIC_BASE_URL || bridgeBaseUrl,
+    ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY || "bridge-local",
+    ANTHROPIC_AUTH_TOKEN: process.env.ANTHROPIC_AUTH_TOKEN || "",
+    CLAUDE_CODE_SKIP_AUTH_LOGIN: process.env.CLAUDE_CODE_SKIP_AUTH_LOGIN || "1",
+    CLAUDE_CODE_ENTRYPOINT: process.env.CLAUDE_CODE_ENTRYPOINT || "claude-vscode",
+  };
+
+  await ensureBridgeRunning(env, bridgeBaseUrl);
+
+  const claudeExecutable = resolveClaudeExecutable();
+  if (process.env.CLAUDE_WRAPPER_TEST === "1") {
+    console.log(
+      JSON.stringify(
+        {
+          bridgeUrl: env.ANTHROPIC_BASE_URL,
+          executable: claudeExecutable.command,
+        },
+        null,
+        2,
+      ),
+    );
+    process.exit(0);
+  }
+
+  const child = spawn(claudeExecutable.command, [...claudeExecutable.args, ...process.argv.slice(2)], {
+    stdio: "inherit",
+    env,
+    cwd: process.cwd(),
+    windowsHide: false,
+  });
+
+  child.on("error", (error) => {
+    console.error(`Failed to start Claude executable: ${error.message}`);
+    process.exit(1);
+  });
+
+  child.on("exit", (code, signal) => {
+    if (signal) {
+      process.kill(process.pid, signal);
+      return;
+    }
+
+    process.exit(code ?? 0);
+  });
+}
+
+function resolveClaudeExecutable() {
+  const override = process.env.CLAUDE_REAL_EXECUTABLE;
+  if (override && fs.existsSync(override)) {
+    return { command: override, args: [] };
+  }
+
+  const candidates = findClaudeExtensionExecutables();
+  if (candidates.length > 0) {
+    return { command: candidates[0], args: [] };
+  }
+
+  return { command: "claude", args: [] };
+}
+
+function findClaudeExtensionExecutables() {
+  const home = process.env.USERPROFILE || process.env.HOME;
+  if (!home) {
+    return [];
+  }
+
+  const extensionRoot = path.join(home, ".vscode", "extensions");
+  if (!fs.existsSync(extensionRoot)) {
+    return [];
+  }
+
+  const matches = [];
+  for (const entry of fs.readdirSync(extensionRoot, { withFileTypes: true })) {
+    if (!entry.isDirectory() || !entry.name.startsWith("anthropic.claude-code-")) {
+      continue;
+    }
+
+    const candidates = [
+      path.join(extensionRoot, entry.name, "resources", "native-binary", "claude.exe"),
+      path.join(extensionRoot, entry.name, "resources", "native-binaries", "win32-x64", "claude.exe"),
+      path.join(extensionRoot, entry.name, "resources", "native-binaries", "win32-arm64", "claude.exe"),
+    ];
+
+    for (const executable of candidates) {
+      if (fs.existsSync(executable)) {
+        matches.push(executable);
+      }
+    }
+  }
+
+  return matches.sort().reverse();
+}
+
+async function ensureBridgeRunning(env, bridgeBaseUrl) {
+  if (await isBridgeHealthy(bridgeBaseUrl)) {
+    return;
+  }
+
+  if (fs.existsSync(bridgePidPath)) {
+    try {
+      const pid = Number.parseInt(fs.readFileSync(bridgePidPath, "utf8").trim(), 10);
+      if (Number.isInteger(pid)) {
+        process.kill(pid, 0);
+      }
+    } catch {
+      safeUnlink(bridgePidPath);
+    }
+  }
+
+  const bridge = spawn(process.execPath, [path.join(repoRoot, "src", "server.js")], {
+    cwd: repoRoot,
+    env,
+    detached: true,
+    stdio: ["ignore", fs.openSync(bridgeLogPath, "a"), fs.openSync(bridgeLogPath, "a")],
+    windowsHide: true,
+  });
+
+  fs.writeFileSync(bridgePidPath, `${bridge.pid}\n`);
+  bridge.unref();
+
+  const deadline = Date.now() + 15000;
+  while (Date.now() < deadline) {
+    if (await isBridgeHealthy(bridgeBaseUrl)) {
+      return;
+    }
+
+    await sleep(400);
+  }
+
+  throw new Error(`Bridge did not become healthy. Check ${bridgeLogPath}`);
+}
+
+async function isBridgeHealthy(bridgeBaseUrl) {
+  try {
+    const response = await fetch(`${bridgeBaseUrl}/health`);
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+
+function loadEnvFile(filePath) {
+  if (!fs.existsSync(filePath)) {
+    return {};
+  }
+
+  const result = {};
+  const raw = fs.readFileSync(filePath, "utf8");
+  for (const line of raw.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) {
+      continue;
+    }
+
+    const separator = trimmed.indexOf("=");
+    if (separator === -1) {
+      continue;
+    }
+
+    const key = trimmed.slice(0, separator).trim();
+    let value = trimmed.slice(separator + 1).trim();
+    if (
+      (value.startsWith("\"") && value.endsWith("\"")) ||
+      (value.startsWith("'") && value.endsWith("'"))
+    ) {
+      value = value.slice(1, -1);
+    }
+
+    result[key] = value;
+  }
+
+  return result;
+}
+
+function safeUnlink(filePath) {
+  try {
+    fs.unlinkSync(filePath);
+  } catch {
+    // ignore
+  }
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+main().catch((error) => {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exit(1);
+});