lynkr 0.1.0

package/src/api/router.js

@@ -0,0 +1,80 @@
+const express = require("express");
+const { processMessage } = require("../orchestrator");
+const { getSession } = require("../sessions");
+const metrics = require("../metrics");
+
+const router = express.Router();
+
+router.get("/health", (req, res) => {
+  res.json({ status: "ok" });
+});
+
+router.get("/debug/session", (req, res) => {
+  if (!req.sessionId) {
+    return res.status(400).json({ error: "missing_session_id", message: "Provide x-session-id header" });
+  }
+  const session = getSession(req.sessionId);
+  if (!session) {
+    return res.status(404).json({ error: "session_not_found", message: "Session not found" });
+  }
+  res.json({ session });
+});
+
+router.post("/v1/messages", async (req, res, next) => {
+  try {
+    metrics.recordRequest();
+    const wantsStream = Boolean(req.body?.stream);
+    const result = await processMessage({
+      payload: req.body,
+      headers: req.headers,
+      session: req.session,
+      options: {
+        maxSteps: req.body?.max_steps,
+        maxDurationMs: req.body?.max_duration_ms,
+      },
+    });
+
+    if (wantsStream) {
+      metrics.recordStreamingStart();
+      res.set({
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive",
+      });
+      if (typeof res.flushHeaders === "function") {
+        res.flushHeaders();
+      }
+
+      const eventPayload = {
+        type: "message",
+        message: result.body,
+      };
+      res.write(`event: message\n`);
+      res.write(`data: ${JSON.stringify(eventPayload)}\n\n`);
+
+      res.write(`event: end\n`);
+      res.write(
+        `data: ${JSON.stringify({ termination: result.terminationReason ?? "completion" })}\n\n`,
+      );
+
+      metrics.recordResponse(result.status);
+      res.end();
+      return;
+    }
+
+    if (result.headers) {
+      Object.entries(result.headers).forEach(([key, value]) => {
+        if (value !== undefined) {
+          res.setHeader(key, value);
+        }
+      });
+    }
+
+    metrics.recordResponse(result.status);
+    res.status(result.status).send(result.body);
+  } catch (error) {
+    next(error);
+  }
+});
+
+module.exports = router;

package/src/cache/prompt.js

@@ -0,0 +1,183 @@
+const crypto = require("crypto");
+const config = require("../config");
+const logger = require("../logger");
+
+function cloneValue(value) {
+  if (typeof structuredClone === "function") {
+    return structuredClone(value);
+  }
+  return JSON.parse(JSON.stringify(value));
+}
+
+function normaliseObject(value) {
+  if (value === null || typeof value !== "object") return value;
+  if (Array.isArray(value)) {
+    return value.map((item) => normaliseObject(item));
+  }
+  const sorted = {};
+  for (const key of Object.keys(value).sort()) {
+    const candidate = value[key];
+    if (candidate === undefined) continue;
+    sorted[key] = normaliseObject(candidate);
+  }
+  return sorted;
+}
+
+function stableStringify(value) {
+  return JSON.stringify(normaliseObject(value));
+}
+
+class PromptCache {
+  constructor(options = {}) {
+    this.enabled = options.enabled === true;
+    this.maxEntries =
+      Number.isInteger(options.maxEntries) && options.maxEntries > 0
+        ? options.maxEntries
+        : 64;
+    this.ttlMs =
+      Number.isInteger(options.ttlMs) && options.ttlMs > 0 ? options.ttlMs : 300000;
+    this.store = new Map();
+  }
+
+  isEnabled() {
+    return this.enabled;
+  }
+
+  buildKey(payload) {
+    if (!this.enabled) return null;
+    if (!payload || typeof payload !== "object") return null;
+    try {
+      const canonical = {
+        model: payload.model ?? null,
+        input: payload.input ?? null,
+        messages: payload.messages ? normaliseObject(payload.messages) : null,
+        tools: payload.tools ? normaliseObject(payload.tools) : null,
+        tool_choice: payload.tool_choice ? normaliseObject(payload.tool_choice) : null,
+        temperature: payload.temperature ?? null,
+        top_p: payload.top_p ?? null,
+        max_tokens: payload.max_tokens ?? null,
+      };
+      const serialised = stableStringify(canonical);
+      return crypto.createHash("sha256").update(serialised).digest("hex");
+    } catch (error) {
+      logger.warn(
+        {
+          err: error,
+        },
+        "Failed to build prompt cache key",
+      );
+      return null;
+    }
+  }
+
+  pruneExpired() {
+    if (!this.enabled) return;
+    if (this.ttlMs <= 0) return;
+    const now = Date.now();
+    for (const [key, entry] of this.store) {
+      if (entry.expiresAt && entry.expiresAt <= now) {
+        this.store.delete(key);
+      }
+    }
+  }
+
+  lookup(payloadOrKey) {
+    if (!this.enabled) {
+      return { key: null, entry: null };
+    }
+    const key =
+      typeof payloadOrKey === "string" ? payloadOrKey : this.buildKey(payloadOrKey);
+    if (!key) {
+      return { key: null, entry: null };
+    }
+
+    this.pruneExpired();
+    const entry = this.store.get(key);
+    if (!entry) {
+      return { key, entry: null };
+    }
+    if (entry.expiresAt && entry.expiresAt <= Date.now()) {
+      this.store.delete(key);
+      return { key, entry: null };
+    }
+
+    this.store.delete(key);
+    this.store.set(key, entry);
+    return { key, entry };
+  }
+
+  fetch(payload) {
+    const { key, entry } = this.lookup(payload);
+    if (!entry) return null;
+    return {
+      key,
+      response: cloneValue(entry.value),
+    };
+  }
+
+  shouldCacheResponse(response) {
+    if (!response) return false;
+    if (response.ok !== true) return false;
+    if (!response.json) return false;
+    if (typeof response.status === "number" && response.status !== 200) return false;
+
+    const choice = response.json?.choices?.[0];
+    if (!choice) return false;
+    if (choice?.finish_reason === "tool_calls") return false;
+
+    const message = choice.message ?? {};
+    if (Array.isArray(message.tool_calls) && message.tool_calls.length > 0) {
+      return false;
+    }
+    return true;
+  }
+
+  storeResponse(payloadOrKey, response) {
+    if (!this.enabled) return null;
+    if (!this.shouldCacheResponse(response)) return null;
+    const key =
+      typeof payloadOrKey === "string" ? payloadOrKey : this.buildKey(payloadOrKey);
+    if (!key) return null;
+
+    this.pruneExpired();
+    const entry = {
+      value: cloneValue(response),
+      createdAt: Date.now(),
+      expiresAt: this.ttlMs > 0 ? Date.now() + this.ttlMs : null,
+    };
+
+    if (this.store.has(key)) {
+      this.store.delete(key);
+    }
+
+    this.store.set(key, entry);
+
+    while (this.store.size > this.maxEntries) {
+      const oldestKey = this.store.keys().next().value;
+      this.store.delete(oldestKey);
+    }
+
+    logger.debug(
+      {
+        cacheKey: key,
+        size: this.store.size,
+      },
+      "Stored response in prompt cache",
+    );
+
+    return key;
+  }
+
+  stats() {
+    return {
+      enabled: this.enabled,
+      size: this.store.size,
+      ttlMs: this.ttlMs,
+      maxEntries: this.maxEntries,
+    };
+  }
+}
+
+const promptCache = new PromptCache(config.promptCache ?? {});
+
+module.exports = promptCache;

package/src/clients/databricks.js

@@ -0,0 +1,72 @@
+const config = require("../config");
+
+if (typeof fetch !== "function") {
+  throw new Error("Node 18+ is required for the built-in fetch API.");
+}
+
+async function performJsonRequest(url, { headers = {}, body }, providerLabel) {
+  const response = await fetch(url, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(body),
+  });
+  const text = await response.text();
+  console.log(`=== ${providerLabel} response ===`);
+  console.log("Status:", response.status);
+  console.log(text);
+  console.log("===========================");
+
+  let json;
+  try {
+    json = JSON.parse(text);
+  } catch {
+    json = null;
+  }
+
+  return {
+    ok: response.ok,
+    status: response.status,
+    json,
+    text,
+    contentType: response.headers.get("content-type"),
+  };
+}
+
+async function invokeDatabricks(body) {
+  if (!config.databricks?.url) {
+    throw new Error("Databricks configuration is missing required URL.");
+  }
+  const headers = {
+    Authorization: `Bearer ${config.databricks.apiKey}`,
+    "Content-Type": "application/json",
+  };
+  return performJsonRequest(config.databricks.url, { headers, body }, "Databricks");
+}
+
+async function invokeAzureAnthropic(body) {
+  if (!config.azureAnthropic?.endpoint) {
+    throw new Error("Azure Anthropic endpoint is not configured.");
+  }
+  const headers = {
+    "Content-Type": "application/json",
+    "x-api-key": config.azureAnthropic.apiKey,
+    "anthropic-version": config.azureAnthropic.version ?? "2023-06-01",
+  };
+  return performJsonRequest(
+    config.azureAnthropic.endpoint,
+    { headers, body },
+    "Azure Anthropic",
+  );
+}
+
+async function invokeModel(body) {
+  const provider = config.modelProvider?.type ?? "databricks";
+  if (provider === "azure-anthropic") {
+    return invokeAzureAnthropic(body);
+  }
+  return invokeDatabricks(body);
+}
+
+module.exports = {
+  invokeModel,
+};

package/src/config/index.js

@@ -0,0 +1,301 @@
+const path = require("path");
+const dotenv = require("dotenv");
+
+dotenv.config();
+
+function trimTrailingSlash(value) {
+  if (typeof value !== "string") return value;
+  return value.replace(/\/$/, "");
+}
+
+function parseJson(value, fallback = null) {
+  if (typeof value !== "string" || value.trim().length === 0) return fallback;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return fallback;
+  }
+}
+
+function parseList(value, options = {}) {
+  if (typeof value !== "string" || value.trim().length === 0) return [];
+  const separator = options.separator ?? ",";
+  return value
+    .split(separator)
+    .map((item) => item.trim())
+    .filter(Boolean);
+}
+
+function parseMountList(value) {
+  if (typeof value !== "string" || value.trim().length === 0) return [];
+  return value
+    .split(";")
+    .map((entry) => entry.trim())
+    .filter(Boolean)
+    .map((entry) => {
+      const parts = entry.split(":");
+      if (parts.length < 2) return null;
+      const host = parts[0]?.trim();
+      const container = parts[1]?.trim();
+      const mode = parts[2]?.trim() || "rw";
+      if (!host || !container) return null;
+      return {
+        host: path.resolve(host),
+        container,
+        mode,
+      };
+    })
+    .filter(Boolean);
+}
+
+function resolveConfigPath(targetPath) {
+  if (typeof targetPath !== "string" || targetPath.trim().length === 0) {
+    return null;
+  }
+  let normalised = targetPath.trim();
+  if (normalised.startsWith("~")) {
+    const home = process.env.HOME || process.env.USERPROFILE;
+    if (home) {
+      normalised = path.join(home, normalised.slice(1));
+    }
+  }
+  return path.resolve(normalised);
+}
+
+const SUPPORTED_MODEL_PROVIDERS = new Set(["databricks", "azure-anthropic"]);
+const rawModelProvider = (process.env.MODEL_PROVIDER ?? "databricks").toLowerCase();
+const modelProvider = SUPPORTED_MODEL_PROVIDERS.has(rawModelProvider)
+  ? rawModelProvider
+  : "databricks";
+
+const rawBaseUrl = trimTrailingSlash(process.env.DATABRICKS_API_BASE);
+const apiKey = process.env.DATABRICKS_API_KEY;
+
+const azureAnthropicEndpoint = process.env.AZURE_ANTHROPIC_ENDPOINT ?? null;
+const azureAnthropicApiKey = process.env.AZURE_ANTHROPIC_API_KEY ?? null;
+const azureAnthropicVersion = process.env.AZURE_ANTHROPIC_VERSION ?? "2023-06-01";
+
+if (modelProvider === "databricks" && (!rawBaseUrl || !apiKey)) {
+  throw new Error("Set DATABRICKS_API_BASE and DATABRICKS_API_KEY before starting the proxy.");
+}
+
+if (modelProvider === "azure-anthropic" && (!azureAnthropicEndpoint || !azureAnthropicApiKey)) {
+  throw new Error(
+    "Set AZURE_ANTHROPIC_ENDPOINT and AZURE_ANTHROPIC_API_KEY before starting the proxy.",
+  );
+}
+
+const endpointPath =
+  process.env.DATABRICKS_ENDPOINT_PATH ??
+  "/serving-endpoints/databricks-claude-sonnet-4-5/invocations";
+
+const databricksUrl =
+  rawBaseUrl && endpointPath
+    ? `${rawBaseUrl}${endpointPath.startsWith("/") ? "" : "/"}${endpointPath}`
+    : null;
+
+const defaultModel =
+  process.env.MODEL_DEFAULT ??
+  (modelProvider === "azure-anthropic" ? "claude-opus-4-5" : "databricks-claude-sonnet-4-5");
+
+const port = Number.parseInt(process.env.PORT ?? "8080", 10);
+const sessionDbPath =
+  process.env.SESSION_DB_PATH ?? path.join(process.cwd(), "data", "sessions.db");
+const workspaceRoot = path.resolve(process.env.WORKSPACE_ROOT ?? process.cwd());
+
+const defaultWebEndpoint = process.env.WEB_SEARCH_ENDPOINT ?? "http://localhost:8888/search";
+let webEndpointHost = null;
+try {
+  const { hostname } = new URL(defaultWebEndpoint);
+  webEndpointHost = hostname.toLowerCase();
+} catch {
+  webEndpointHost = null;
+}
+
+const allowAllWebHosts = process.env.WEB_SEARCH_ALLOW_ALL !== "false";
+const configuredAllowedHosts =
+  process.env.WEB_SEARCH_ALLOWED_HOSTS?.split(",")
+    .map((host) => host.trim().toLowerCase())
+    .filter(Boolean) ?? [];
+const webAllowedHosts = allowAllWebHosts
+  ? null
+  : new Set([webEndpointHost, "localhost", "127.0.0.1"].filter(Boolean).concat(configuredAllowedHosts));
+const webTimeoutMs = Number.parseInt(process.env.WEB_SEARCH_TIMEOUT_MS ?? "10000", 10);
+
+const policyMaxSteps = Number.parseInt(process.env.POLICY_MAX_STEPS ?? "8", 10);
+const policyMaxToolCalls = Number.parseInt(process.env.POLICY_MAX_TOOL_CALLS ?? "12", 10);
+const policyDisallowedTools =
+  process.env.POLICY_DISALLOWED_TOOLS?.split(",")
+    .map((tool) => tool.trim())
+    .filter(Boolean) ?? [];
+const policyGitAllowPush = process.env.POLICY_GIT_ALLOW_PUSH === "true";
+const policyGitAllowPull = process.env.POLICY_GIT_ALLOW_PULL !== "false";
+const policyGitAllowCommit = process.env.POLICY_GIT_ALLOW_COMMIT !== "false";
+const policyGitTestCommand = process.env.POLICY_GIT_TEST_COMMAND ?? null;
+const policyGitRequireTests = process.env.POLICY_GIT_REQUIRE_TESTS === "true";
+const policyGitCommitRegex = process.env.POLICY_GIT_COMMIT_REGEX ?? null;
+const policyGitAutoStash = process.env.POLICY_GIT_AUTOSTASH === "true";
+
+const sandboxEnabled = process.env.MCP_SANDBOX_ENABLED !== "false";
+const sandboxImage = process.env.MCP_SANDBOX_IMAGE ?? null;
+const sandboxRuntime = process.env.MCP_SANDBOX_RUNTIME ?? "docker";
+const sandboxContainerWorkspace =
+  process.env.MCP_SANDBOX_CONTAINER_WORKSPACE ?? "/workspace";
+const sandboxMountWorkspace = process.env.MCP_SANDBOX_MOUNT_WORKSPACE !== "false";
+const sandboxAllowNetworking = process.env.MCP_SANDBOX_ALLOW_NETWORKING === "true";
+const sandboxNetworkMode = sandboxAllowNetworking
+  ? process.env.MCP_SANDBOX_NETWORK_MODE ?? "bridge"
+  : "none";
+const sandboxPassthroughEnv = parseList(
+  process.env.MCP_SANDBOX_PASSTHROUGH_ENV ?? "PATH,LANG,LC_ALL,TERM,HOME",
+);
+const sandboxExtraMounts = parseMountList(process.env.MCP_SANDBOX_EXTRA_MOUNTS ?? "");
+const sandboxDefaultTimeoutMs = Number.parseInt(
+  process.env.MCP_SANDBOX_TIMEOUT_MS ?? "20000",
+  10,
+);
+const sandboxUser = process.env.MCP_SANDBOX_USER ?? null;
+const sandboxEntrypoint = process.env.MCP_SANDBOX_ENTRYPOINT ?? null;
+const sandboxReuseSessions = process.env.MCP_SANDBOX_REUSE_SESSION !== "false";
+
+const sandboxPermissionMode =
+  (process.env.MCP_SANDBOX_PERMISSION_MODE ?? "auto").toLowerCase();
+const sandboxPermissionAllow = parseList(process.env.MCP_SANDBOX_PERMISSION_ALLOW ?? "");
+const sandboxPermissionDeny = parseList(process.env.MCP_SANDBOX_PERMISSION_DENY ?? "");
+
+const sandboxManifestPath = resolveConfigPath(process.env.MCP_SERVER_MANIFEST ?? null);
+
+let manifestDirList = null;
+if (process.env.MCP_MANIFEST_DIRS === "") {
+  manifestDirList = [];
+} else if (process.env.MCP_MANIFEST_DIRS) {
+  manifestDirList = parseList(process.env.MCP_MANIFEST_DIRS);
+} else {
+  manifestDirList = ["~/.claude/mcp"];
+}
+const sandboxManifestDirs = manifestDirList
+  .map((dir) => resolveConfigPath(dir))
+  .filter((dir) => typeof dir === "string" && dir.length > 0);
+
+const promptCacheEnabled = process.env.PROMPT_CACHE_ENABLED !== "false";
+const promptCacheMaxEntriesRaw = Number.parseInt(
+  process.env.PROMPT_CACHE_MAX_ENTRIES ?? "64",
+  10,
+);
+const promptCacheTtlRaw = Number.parseInt(
+  process.env.PROMPT_CACHE_TTL_MS ?? "300000",
+  10,
+);
+
+const testDefaultCommand = process.env.WORKSPACE_TEST_COMMAND ?? null;
+const testDefaultArgs = parseList(process.env.WORKSPACE_TEST_ARGS ?? "");
+const testTimeoutMs = Number.parseInt(process.env.WORKSPACE_TEST_TIMEOUT_MS ?? "600000", 10);
+const testSandboxMode = (process.env.WORKSPACE_TEST_SANDBOX ?? "auto").toLowerCase();
+let testCoverageFiles = parseList(
+  process.env.WORKSPACE_TEST_COVERAGE_FILES ?? "coverage/coverage-summary.json",
+);
+if (testCoverageFiles.length === 0) {
+  testCoverageFiles = [];
+}
+const testProfiles = parseJson(process.env.WORKSPACE_TEST_PROFILES ?? "", null);
+
+const config = {
+  env: process.env.NODE_ENV ?? "development",
+  port: Number.isNaN(port) ? 8080 : port,
+  databricks: {
+    baseUrl: rawBaseUrl,
+    apiKey,
+    endpointPath,
+    url: databricksUrl,
+  },
+  azureAnthropic: {
+    endpoint: azureAnthropicEndpoint,
+    apiKey: azureAnthropicApiKey,
+    version: azureAnthropicVersion,
+  },
+  modelProvider: {
+    type: modelProvider,
+    defaultModel,
+  },
+  server: {
+    jsonLimit: process.env.REQUEST_JSON_LIMIT ?? "1gb",
+  },
+  logger: {
+    level: process.env.LOG_LEVEL ?? "info",
+  },
+  sessionStore: {
+    dbPath: sessionDbPath,
+  },
+  workspace: {
+    root: workspaceRoot,
+  },
+  webSearch: {
+    endpoint: defaultWebEndpoint,
+    apiKey: process.env.WEB_SEARCH_API_KEY ?? null,
+    allowedHosts: allowAllWebHosts ? null : Array.from(webAllowedHosts ?? []),
+    allowAllHosts: allowAllWebHosts,
+    enabled: true,
+    timeoutMs: Number.isNaN(webTimeoutMs) ? 10000 : webTimeoutMs,
+  },
+  policy: {
+    maxStepsPerTurn: Number.isNaN(policyMaxSteps) ? 8 : policyMaxSteps,
+    maxToolCallsPerTurn: Number.isNaN(policyMaxToolCalls) ? 12 : policyMaxToolCalls,
+    disallowedTools: policyDisallowedTools,
+    git: {
+      allowPush: policyGitAllowPush,
+      allowPull: policyGitAllowPull,
+      allowCommit: policyGitAllowCommit,
+      testCommand: policyGitTestCommand,
+      requireTests: policyGitRequireTests,
+      commitMessageRegex: policyGitCommitRegex,
+      autoStash: policyGitAutoStash,
+    },
+  },
+  mcp: {
+    sandbox: {
+      enabled: sandboxEnabled && Boolean(sandboxImage),
+      runtime: sandboxRuntime,
+      image: sandboxImage,
+      containerWorkspace: sandboxContainerWorkspace,
+      mountWorkspace: sandboxMountWorkspace,
+      allowNetworking: sandboxAllowNetworking,
+      networkMode: sandboxNetworkMode,
+      passthroughEnv: sandboxPassthroughEnv,
+      extraMounts: sandboxExtraMounts,
+      defaultTimeoutMs: Number.isNaN(sandboxDefaultTimeoutMs)
+        ? 20000
+        : sandboxDefaultTimeoutMs,
+      user: sandboxUser,
+      entrypoint: sandboxEntrypoint,
+      reuseSession: sandboxReuseSessions,
+    },
+    permissions: {
+      mode: ["auto", "require", "deny"].includes(sandboxPermissionMode)
+        ? sandboxPermissionMode
+        : "auto",
+      allow: sandboxPermissionAllow,
+      deny: sandboxPermissionDeny,
+    },
+    servers: {
+      manifestPath: sandboxManifestPath,
+      manifestDirs: sandboxManifestDirs,
+    },
+  },
+  promptCache: {
+    enabled: promptCacheEnabled,
+    maxEntries: Number.isNaN(promptCacheMaxEntriesRaw) ? 64 : promptCacheMaxEntriesRaw,
+    ttlMs: Number.isNaN(promptCacheTtlRaw) ? 300000 : promptCacheTtlRaw,
+  },
+  tests: {
+    defaultCommand: testDefaultCommand ? testDefaultCommand.trim() : null,
+    defaultArgs: testDefaultArgs,
+    timeoutMs: Number.isNaN(testTimeoutMs) ? 600000 : testTimeoutMs,
+    sandbox: ["always", "never", "auto"].includes(testSandboxMode) ? testSandboxMode : "auto",
+    coverage: {
+      files: testCoverageFiles,
+    },
+    profiles: Array.isArray(testProfiles) ? testProfiles : null,
+  },
+};
+
+module.exports = config;