@remnic/connector-weclone 1.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Joshua Warren
+
+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,146 @@
+# @remnic/connector-weclone
+
+Memory-aware OpenAI-compatible proxy that adds Remnic persistent memory to deployed
+[WeClone](https://github.com/xming521/weclone) avatars.
+
+WeClone fine-tunes a model to sound like you. Remnic gives it memory. Together the
+avatar remembers what happened yesterday and sounds like you while doing it.
+
+## What it does
+
+- Runs as a local OpenAI-compatible HTTP proxy in front of a WeClone API server.
+- On every `POST /v1/chat/completions`, calls Remnic `/engram/v1/recall` and injects
+  retrieved memory into the system prompt before forwarding to WeClone.
+- After WeClone responds, calls `/engram/v1/observe` fire-and-forget so the turn is
+  buffered for extraction.
+- Forwards all other OpenAI-compatible endpoints (`/v1/models`, uploads, etc.)
+  transparently.
+- Supports single-session and per-caller (`X-Caller-Id` header or `user` field)
+  isolation modes.
+- Degrades gracefully: if Remnic is unreachable, the request is still forwarded to
+  WeClone without memory injection.
+
+## Install
+
+The proxy ships as part of the Remnic monorepo and is wired into the `remnic`
+CLI. The recommended install path is:
+
+```bash
+remnic connectors install weclone \
+  --config wecloneApiUrl=http://localhost:8000/v1 \
+  --config proxyPort=8100
+```
+
+This writes two files:
+
+- `~/.config/engram/.engram-connectors/connectors/weclone.json` — connector
+  registry entry (tracked by `remnic connectors list / remove / doctor`).
+- `~/.remnic/connectors/weclone.json` — proxy config read by
+  `remnic-weclone-proxy` at startup.
+
+An auth token for the Remnic daemon is also minted automatically and stored in
+the proxy config so the proxy can authenticate with the daemon.
+
+## Run
+
+Once installed, start the proxy:
+
+```bash
+remnic-weclone-proxy
+```
+
+Or point it at a custom config path:
+
+```bash
+remnic-weclone-proxy --config /path/to/weclone.json
+```
+
+The `REMNIC_HOME` environment variable overrides the default config location
+(`~/.remnic`) — useful for tests and sandboxed deployments.
+
+## Configure
+
+The proxy config file accepts the following fields:
+
+| Field | Default | Description |
+| --- | --- | --- |
+| `wecloneApiUrl` | `http://localhost:8000/v1` | Base URL of the WeClone API. Both path-prefixed (`/v1`, `/weclone/v1`) and bare origins are supported. |
+| `wecloneModelName` | `weclone-avatar` | Optional fine-tuned model name passed through to WeClone. |
+| `proxyPort` | `8100` | Local port the proxy listens on. |
+| `remnicDaemonUrl` | `http://localhost:4318` | URL of the Remnic daemon exposing `/engram/v1/recall` and `/engram/v1/observe`. |
+| `remnicAuthToken` | — | Bearer token for the Remnic daemon. Populated by `remnic connectors install weclone`. |
+| `sessionStrategy` | `single` | `single` uses one shared memory session; `caller-id` maps each caller (via `X-Caller-Id` header or `user` field) to its own namespace. |
+| `memoryInjection.maxTokens` | `1500` | Approximate token budget for injected memory. |
+| `memoryInjection.position` | `system-append` | `system-append` appends memory to an existing system message; `system-prepend` prepends. |
+| `memoryInjection.template` | `[Memory Context]\n{memories}\n[End Memory Context]` | Template used to wrap recalled memories. `{memories}` is the sole placeholder. |
+
+### Example config
+
+```json
+{
+  "wecloneApiUrl": "http://localhost:8000/v1",
+  "proxyPort": 8100,
+  "remnicDaemonUrl": "http://localhost:4318",
+  "remnicAuthToken": "${REMNIC_TOKEN}",
+  "sessionStrategy": "caller-id",
+  "memoryInjection": {
+    "maxTokens": 1500,
+    "position": "system-append",
+    "template": "[Memory Context]\n{memories}\n[End Memory Context]"
+  }
+}
+```
+
+> Config examples use placeholder token strings. Never commit real bearer
+> tokens to version control.
+
+## Architecture
+
+```
+Caller (Discord bot, Telegram bot, AstrBot, LangBot, ...)
+  │
+  ▼
+┌──────────────────────────────┐
+│  remnic-weclone-proxy        │
+│                              │
+│  1. Intercept chat completion│
+│  2. POST /engram/v1/recall   │  ──► Remnic daemon (:4318)
+│  3. Inject memory into       │
+│     system prompt            │
+│  4. Forward to WeClone API   │  ──► WeClone model server (:8000)
+│  5. Capture response         │
+│  6. POST /engram/v1/observe  │  ──► Remnic daemon (:4318)
+│     (fire-and-forget)        │
+│  7. Return response to caller│
+└──────────────────────────────┘
+```
+
+### Session identity
+
+| `sessionStrategy` | Behavior |
+| --- | --- |
+| `single` | All callers share a single `weclone-default` session key. Good for a one-user avatar. |
+| `caller-id` | The proxy extracts the session key from `X-Caller-Id` header, then `body.user`, then falls back to `default`. |
+
+Callers wiring up a Discord bot should pass the Discord user ID as
+`X-Caller-Id` so memory stays partitioned per user.
+
+## Verification
+
+- `GET /health` — returns `{ "status": "ok", "wecloneApi": "..." }` if the proxy
+  is running.
+- `remnic connectors doctor weclone` — verifies both config files exist.
+
+## Security notes
+
+- The proxy config file is written with owner-only permissions (`0o600`) because
+  it embeds a Remnic bearer token.
+- Hop-by-hop headers (`connection`, `keep-alive`, `proxy-authorization`, etc.)
+  are stripped on forward and response paths so proxy credentials never leak
+  upstream or downstream.
+- Multimodal content (image parts, etc.) is preserved verbatim; only the text
+  parts of the last user message are used for recall.
+
+## License
+
+MIT

package/dist/chunk-7V67D4WU.js

@@ -0,0 +1,604 @@
+// openclaw-engram: Local-first memory plugin
+
+// src/format.ts
+var CHARS_PER_TOKEN = 4;
+function formatMemoryBlock(memories, template, maxTokens) {
+  if (memories.length === 0) {
+    return "";
+  }
+  const sorted = [...memories].sort((a, b) => {
+    const aConf = a.confidence ?? -1;
+    const bConf = b.confidence ?? -1;
+    return bConf - aConf;
+  });
+  const maxChars = maxTokens * CHARS_PER_TOKEN;
+  let totalChars = 0;
+  const included = [];
+  for (const memory of sorted) {
+    const line = memory.content;
+    if (totalChars + line.length > maxChars && included.length > 0) {
+      break;
+    }
+    included.push(line);
+    totalChars += line.length;
+  }
+  if (included.length === 0) {
+    return "";
+  }
+  const memoriesText = included.join("\n");
+  return template.replace("{memories}", () => memoriesText);
+}
+
+// src/session.ts
+var SingleSessionMapper = class {
+  key;
+  constructor(key = "weclone-default") {
+    this.key = key;
+  }
+  resolve(_headers, _body) {
+    return this.key;
+  }
+};
+var CallerIdSessionMapper = class {
+  fallback;
+  constructor(fallback = "default") {
+    this.fallback = fallback;
+  }
+  resolve(headers, body) {
+    const headerValue = headers["x-caller-id"];
+    if (typeof headerValue === "string" && headerValue.length > 0) {
+      return headerValue;
+    }
+    if (typeof body.user === "string" && body.user.length > 0) {
+      return body.user;
+    }
+    return this.fallback;
+  }
+};
+
+// src/proxy.ts
+import * as http from "http";
+function readBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    req.on("data", (chunk) => chunks.push(chunk));
+    req.on("end", () => resolve(Buffer.concat(chunks).toString("utf-8")));
+    req.on("error", reject);
+  });
+}
+function readRawBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    req.on("data", (chunk) => chunks.push(chunk));
+    req.on("end", () => resolve(Buffer.concat(chunks)));
+    req.on("error", reject);
+  });
+}
+function flattenHeaders(raw) {
+  const result = {};
+  for (const [key, val] of Object.entries(raw)) {
+    if (val === void 0) continue;
+    result[key] = Array.isArray(val) ? val.join(", ") : val;
+  }
+  return result;
+}
+function remnicHeaders(authToken) {
+  const headers = { "Content-Type": "application/json" };
+  if (authToken) {
+    headers["Authorization"] = `Bearer ${authToken}`;
+  }
+  return headers;
+}
+async function recallMemories(daemonUrl, sessionKey, query, authToken) {
+  const url = `${daemonUrl}/engram/v1/recall`;
+  const res = await fetch(url, {
+    method: "POST",
+    headers: remnicHeaders(authToken),
+    body: JSON.stringify({ sessionKey, query })
+  });
+  if (!res.ok) {
+    throw new Error(`Remnic recall returned ${res.status}: ${await res.text()}`);
+  }
+  const data = await res.json();
+  const memories = (data.results ?? []).map((r) => ({
+    content: r.preview || r.content || "",
+    confidence: r.confidence,
+    category: r.category
+  }));
+  return memories;
+}
+function observeTurn(daemonUrl, sessionKey, userMessage, assistantMessage, authToken) {
+  const url = `${daemonUrl}/engram/v1/observe`;
+  fetch(url, {
+    method: "POST",
+    headers: remnicHeaders(authToken),
+    body: JSON.stringify({
+      sessionKey,
+      messages: [
+        { role: "user", content: userMessage },
+        { role: "assistant", content: assistantMessage }
+      ]
+    })
+  }).catch(() => {
+  });
+}
+function extractTextContent(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  const parts = [];
+  for (const part of content) {
+    if (part && typeof part === "object" && part.type === "text") {
+      const text = part.text;
+      if (typeof text === "string") parts.push(text);
+    }
+  }
+  return parts.join("\n");
+}
+function lastUserMessage(messages) {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    if (messages[i].role === "user") {
+      return extractTextContent(messages[i].content);
+    }
+  }
+  return "";
+}
+function extractAssistantReply(responseBody) {
+  const choices = responseBody.choices;
+  if (choices && choices.length > 0) {
+    return choices[0]?.message?.content ?? "";
+  }
+  return "";
+}
+function stripTrailingSlashes(s) {
+  let end = s.length;
+  while (end > 0 && s.charCodeAt(end - 1) === 47) {
+    end--;
+  }
+  return end === s.length ? s : s.slice(0, end);
+}
+function splitBaseUrl(urlStr) {
+  try {
+    const parsed = new URL(urlStr);
+    const basePath = stripTrailingSlashes(parsed.pathname);
+    return { origin: parsed.origin, basePath };
+  } catch {
+    const schemeEnd = urlStr.indexOf("://");
+    if (schemeEnd === -1) {
+      return { origin: stripTrailingSlashes(urlStr), basePath: "" };
+    }
+    const afterScheme = urlStr.slice(schemeEnd + 3);
+    const pathStart = afterScheme.indexOf("/");
+    if (pathStart === -1) {
+      return { origin: urlStr, basePath: "" };
+    }
+    const origin = urlStr.slice(0, schemeEnd + 3 + pathStart);
+    const basePath = stripTrailingSlashes(afterScheme.slice(pathStart));
+    return { origin, basePath };
+  }
+}
+var HOP_BY_HOP_REQUEST_HEADERS = /* @__PURE__ */ new Set([
+  "connection",
+  "keep-alive",
+  "proxy-authenticate",
+  "proxy-authorization",
+  "te",
+  "trailer",
+  "transfer-encoding",
+  "upgrade"
+]);
+var HOP_BY_HOP_RESPONSE_HEADERS = /* @__PURE__ */ new Set([
+  "transfer-encoding",
+  "content-encoding",
+  "connection",
+  "keep-alive",
+  "upgrade",
+  "proxy-authenticate",
+  "proxy-authorization",
+  "te",
+  "trailer"
+]);
+async function transparentProxy(weclone, method, path, headers, body, res) {
+  const qIdx = path.indexOf("?");
+  const rawPath = qIdx === -1 ? path : path.slice(0, qIdx);
+  const querySuffix = qIdx === -1 ? "" : path.slice(qIdx);
+  let upstreamPathname = rawPath;
+  if (weclone.basePath.length > 0) {
+    if (rawPath === "/v1" || rawPath.startsWith("/v1/")) {
+      upstreamPathname = `${weclone.basePath}${rawPath.slice(3)}`;
+    } else if (!rawPath.startsWith(weclone.basePath)) {
+      upstreamPathname = `${weclone.basePath}${rawPath}`;
+    }
+  }
+  const targetUrl = `${weclone.origin}${upstreamPathname}${querySuffix}`;
+  const forwardHeaders = {};
+  for (const [key, value] of Object.entries(headers)) {
+    if (key === "host" || HOP_BY_HOP_REQUEST_HEADERS.has(key)) continue;
+    if (key === "content-length") continue;
+    forwardHeaders[key] = value;
+  }
+  const fetchInit = {
+    method,
+    headers: forwardHeaders
+  };
+  if (body && method !== "GET" && method !== "HEAD") {
+    const rawBody = new ArrayBuffer(body.byteLength);
+    new Uint8Array(rawBody).set(body);
+    fetchInit.body = rawBody;
+  }
+  try {
+    const upstream = await fetch(targetUrl, fetchInit);
+    const responseBody = await upstream.arrayBuffer();
+    const responseBuffer = Buffer.from(responseBody);
+    const responseHeaders = {};
+    for (const [key, value] of upstream.headers.entries()) {
+      if (!HOP_BY_HOP_RESPONSE_HEADERS.has(key.toLowerCase())) {
+        responseHeaders[key] = value;
+      }
+    }
+    responseHeaders["content-length"] = String(responseBuffer.length);
+    res.writeHead(upstream.status, responseHeaders);
+    res.end(responseBuffer);
+  } catch (_err) {
+    res.writeHead(502, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: "upstream_unreachable" }));
+  }
+}
+function createWeCloneProxy(config) {
+  const wecloneApiUrl = stripTrailingSlashes(config.wecloneApiUrl);
+  const remnicDaemonUrl = stripTrailingSlashes(config.remnicDaemonUrl);
+  const wecloneParts = splitBaseUrl(wecloneApiUrl);
+  const sessionMapper = config.sessionStrategy === "caller-id" ? new CallerIdSessionMapper() : new SingleSessionMapper();
+  let server = null;
+  let resolvedPort = config.proxyPort;
+  const requestHandler = async (req, res) => {
+    const url = req.url ?? "/";
+    const method = (req.method ?? "GET").toUpperCase();
+    let pathname = url;
+    const queryStart = url.indexOf("?");
+    if (queryStart !== -1) pathname = url.slice(0, queryStart);
+    const normalizedPathname = pathname.length > 1 && pathname.endsWith("/") ? pathname.slice(0, -1) : pathname;
+    if (normalizedPathname === "/health" && method === "GET") {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({
+        status: "ok",
+        wecloneApi: config.wecloneApiUrl
+      }));
+      return;
+    }
+    if (normalizedPathname === "/v1/chat/completions" && method === "POST") {
+      let bodyStr;
+      try {
+        bodyStr = await readBody(req);
+      } catch {
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "bad_request", detail: "Could not read request body" }));
+        return;
+      }
+      let parsed;
+      try {
+        parsed = JSON.parse(bodyStr);
+      } catch {
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "bad_request", detail: "Invalid JSON body" }));
+        return;
+      }
+      const headers = req.headers;
+      const sessionKey = sessionMapper.resolve(headers, parsed);
+      if (parsed.messages !== void 0 && !Array.isArray(parsed.messages)) {
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end(
+          JSON.stringify({
+            error: "bad_request",
+            detail: "messages must be an array"
+          })
+        );
+        return;
+      }
+      const rawMessages = [];
+      for (const raw of parsed.messages ?? []) {
+        if (raw === null || typeof raw !== "object") continue;
+        const entry = raw;
+        rawMessages.push({
+          role: typeof entry.role === "string" ? entry.role : "",
+          content: entry.content
+        });
+      }
+      const query = lastUserMessage(rawMessages);
+      let memoryBlock = "";
+      if (query.length > 0) {
+        try {
+          const memories = await recallMemories(
+            remnicDaemonUrl,
+            sessionKey,
+            query,
+            config.remnicAuthToken
+          );
+          memoryBlock = formatMemoryBlock(
+            memories,
+            config.memoryInjection.template,
+            config.memoryInjection.maxTokens
+          );
+        } catch {
+        }
+      }
+      const outMessages = [];
+      const firstSystemIdx = rawMessages.findIndex((m) => m.role === "system");
+      const position = config.memoryInjection.position;
+      if (memoryBlock.length === 0) {
+        for (const m of rawMessages) outMessages.push(m);
+      } else if (firstSystemIdx === -1) {
+        outMessages.push({ role: "system", content: memoryBlock });
+        for (const m of rawMessages) outMessages.push(m);
+      } else {
+        for (let i = 0; i < rawMessages.length; i++) {
+          const m = rawMessages[i];
+          if (i === firstSystemIdx) {
+            const existing = extractTextContent(m.content);
+            outMessages.push({
+              role: "system",
+              content: position === "system-prepend" ? `${memoryBlock}
+
+${existing}` : `${existing}
+
+${memoryBlock}`
+            });
+          } else {
+            outMessages.push(m);
+          }
+        }
+      }
+      const modifiedBody = {
+        ...parsed,
+        messages: outMessages
+      };
+      const chatBase = wecloneParts.basePath.length > 0 ? wecloneParts.basePath : "/v1";
+      const qIdx = url.indexOf("?");
+      const querySuffix = qIdx === -1 ? "" : url.slice(qIdx);
+      const targetUrl = `${wecloneParts.origin}${chatBase}/chat/completions${querySuffix}`;
+      const forwardHeaders = {
+        "Content-Type": "application/json"
+      };
+      const authHeader = req.headers["authorization"];
+      if (typeof authHeader === "string") {
+        forwardHeaders["Authorization"] = authHeader;
+      }
+      try {
+        const upstream = await fetch(targetUrl, {
+          method: "POST",
+          headers: forwardHeaders,
+          body: JSON.stringify(modifiedBody)
+        });
+        if (parsed.stream === true) {
+          if (!upstream.ok) {
+            const errBody = await upstream.arrayBuffer();
+            res.writeHead(upstream.status, {
+              "content-type": upstream.headers.get("content-type") || "application/json"
+            });
+            res.end(Buffer.from(errBody));
+            return;
+          }
+          res.writeHead(upstream.status, {
+            "Content-Type": "text/event-stream",
+            "Cache-Control": "no-cache",
+            "Connection": "keep-alive"
+          });
+          const reader = upstream.body?.getReader();
+          if (!reader) {
+            res.end();
+            return;
+          }
+          const chunks = [];
+          try {
+            while (true) {
+              const { done, value } = await reader.read();
+              if (done) break;
+              chunks.push(value);
+              res.write(value);
+            }
+          } finally {
+            res.end();
+          }
+          try {
+            const fullText = Buffer.concat(chunks).toString("utf-8");
+            const contentParts = [];
+            for (const line of fullText.split("\n")) {
+              if (!line.startsWith("data: ") || line === "data: [DONE]") continue;
+              try {
+                const event = JSON.parse(line.slice(6));
+                const delta = event.choices?.[0]?.delta?.content;
+                if (delta) contentParts.push(delta);
+              } catch {
+              }
+            }
+            if (contentParts.length > 0 && query.length > 0) {
+              observeTurn(
+                remnicDaemonUrl,
+                sessionKey,
+                query,
+                contentParts.join(""),
+                config.remnicAuthToken
+              );
+            }
+          } catch {
+          }
+          return;
+        }
+        const responseBuffer = await upstream.arrayBuffer();
+        const responseBytes = Buffer.from(responseBuffer);
+        let assistantReply = "";
+        try {
+          const responseJson = JSON.parse(
+            responseBytes.toString("utf-8")
+          );
+          assistantReply = extractAssistantReply(responseJson);
+        } catch {
+        }
+        if (query.length > 0 && assistantReply.length > 0) {
+          observeTurn(remnicDaemonUrl, sessionKey, query, assistantReply, config.remnicAuthToken);
+        }
+        const chatResponseHeaders = {};
+        for (const [key, value] of upstream.headers.entries()) {
+          if (!HOP_BY_HOP_RESPONSE_HEADERS.has(key.toLowerCase())) {
+            chatResponseHeaders[key] = value;
+          }
+        }
+        chatResponseHeaders["content-length"] = String(responseBytes.length);
+        res.writeHead(upstream.status, chatResponseHeaders);
+        res.end(responseBytes);
+      } catch (_err) {
+        res.writeHead(502, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({
+          error: "upstream_unreachable"
+        }));
+      }
+      return;
+    }
+    const body = method !== "GET" && method !== "HEAD" ? await readRawBody(req) : null;
+    const flat = flattenHeaders(req.headers);
+    await transparentProxy(wecloneParts, method, url, flat, body, res);
+  };
+  return {
+    get port() {
+      return resolvedPort;
+    },
+    start() {
+      return new Promise((resolve, reject) => {
+        server = http.createServer((req, res) => {
+          requestHandler(req, res).catch((_err) => {
+            if (!res.headersSent) {
+              res.writeHead(500, { "Content-Type": "application/json" });
+              res.end(JSON.stringify({ error: "internal_proxy_error" }));
+            }
+          });
+        });
+        server.on("error", reject);
+        server.listen(config.proxyPort, () => {
+          const addr = server.address();
+          if (typeof addr === "object" && addr !== null) {
+            resolvedPort = addr.port;
+          }
+          resolve();
+        });
+      });
+    },
+    stop() {
+      return new Promise((resolve, reject) => {
+        if (!server) {
+          resolve();
+          return;
+        }
+        server.close((err) => {
+          server = null;
+          if (err) reject(err);
+          else resolve();
+        });
+      });
+    }
+  };
+}
+
+// src/config.ts
+var DEFAULT_CONFIG = {
+  wecloneApiUrl: "http://localhost:8000/v1",
+  wecloneModelName: "weclone-avatar",
+  proxyPort: 8100,
+  remnicDaemonUrl: "http://localhost:4318",
+  sessionStrategy: "single",
+  memoryInjection: {
+    maxTokens: 1500,
+    position: "system-append",
+    template: "[Memory Context]\n{memories}\n[End Memory Context]"
+  }
+};
+var VALID_SESSION_STRATEGIES = ["caller-id", "single"];
+var VALID_POSITIONS = ["system-append", "system-prepend"];
+function parseConfig(raw) {
+  if (typeof raw !== "object" || raw === null) {
+    throw new Error("Config must be a non-null object");
+  }
+  const obj = raw;
+  if (typeof obj.wecloneApiUrl !== "string" || obj.wecloneApiUrl.length === 0) {
+    throw new Error(
+      "Config 'wecloneApiUrl' is required and must be a non-empty string"
+    );
+  }
+  if (typeof obj.proxyPort !== "number" || !Number.isInteger(obj.proxyPort) || obj.proxyPort <= 0 || obj.proxyPort > 65535) {
+    throw new Error(
+      "Config 'proxyPort' is required and must be an integer between 1 and 65535"
+    );
+  }
+  if (typeof obj.remnicDaemonUrl !== "string" || obj.remnicDaemonUrl.length === 0) {
+    throw new Error(
+      "Config 'remnicDaemonUrl' is required and must be a non-empty string"
+    );
+  }
+  let remnicAuthToken;
+  if (obj.remnicAuthToken !== void 0) {
+    if (typeof obj.remnicAuthToken !== "string" || obj.remnicAuthToken.length === 0) {
+      throw new Error(
+        "Config 'remnicAuthToken' must be a non-empty string when provided"
+      );
+    }
+    remnicAuthToken = obj.remnicAuthToken;
+  }
+  const wecloneModelName = obj.wecloneModelName !== void 0 ? String(obj.wecloneModelName) : DEFAULT_CONFIG.wecloneModelName;
+  let sessionStrategy = DEFAULT_CONFIG.sessionStrategy;
+  if (obj.sessionStrategy !== void 0) {
+    if (!VALID_SESSION_STRATEGIES.includes(obj.sessionStrategy)) {
+      throw new Error(
+        `Config 'sessionStrategy' must be one of: ${VALID_SESSION_STRATEGIES.join(", ")}. Got: ${JSON.stringify(obj.sessionStrategy)}`
+      );
+    }
+    sessionStrategy = obj.sessionStrategy;
+  }
+  let memoryInjection = { ...DEFAULT_CONFIG.memoryInjection };
+  if (obj.memoryInjection !== void 0) {
+    if (typeof obj.memoryInjection !== "object" || obj.memoryInjection === null) {
+      throw new Error("Config 'memoryInjection' must be an object");
+    }
+    const mi = obj.memoryInjection;
+    if (mi.maxTokens !== void 0) {
+      if (typeof mi.maxTokens !== "number" || !Number.isInteger(mi.maxTokens) || mi.maxTokens <= 0) {
+        throw new Error(
+          "Config 'memoryInjection.maxTokens' must be a positive integer"
+        );
+      }
+      memoryInjection.maxTokens = mi.maxTokens;
+    }
+    if (mi.position !== void 0) {
+      if (!VALID_POSITIONS.includes(mi.position)) {
+        throw new Error(
+          `Config 'memoryInjection.position' must be one of: ${VALID_POSITIONS.join(", ")}. Got: ${JSON.stringify(mi.position)}`
+        );
+      }
+      memoryInjection.position = mi.position;
+    }
+    if (mi.template !== void 0) {
+      if (typeof mi.template !== "string" || mi.template.length === 0) {
+        throw new Error(
+          "Config 'memoryInjection.template' must be a non-empty string"
+        );
+      }
+      memoryInjection.template = mi.template;
+    }
+  }
+  return {
+    wecloneApiUrl: obj.wecloneApiUrl,
+    wecloneModelName,
+    proxyPort: obj.proxyPort,
+    remnicDaemonUrl: obj.remnicDaemonUrl,
+    remnicAuthToken,
+    sessionStrategy,
+    memoryInjection
+  };
+}
+
+export {
+  formatMemoryBlock,
+  SingleSessionMapper,
+  CallerIdSessionMapper,
+  createWeCloneProxy,
+  DEFAULT_CONFIG,
+  parseConfig
+};
+//# sourceMappingURL=chunk-7V67D4WU.js.map

package/dist/chunk-7V67D4WU.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/format.ts","../src/session.ts","../src/proxy.ts","../src/config.ts"],"sourcesContent":["/**\n * Memory format adapter.\n *\n * Converts Remnic recall results into system prompt sections that\n * can be injected into OpenAI-compatible chat completion requests.\n */\n\nexport interface RecallResult {\n  content: string;\n  confidence?: number;\n  category?: string;\n}\n\nconst CHARS_PER_TOKEN = 4;\n\n/**\n * Format recall results into a memory block suitable for prompt injection.\n *\n * - Sorts memories by confidence (highest first; missing confidence sorts last)\n * - Truncates combined content to fit within `maxTokens` (approx 4 chars/token)\n * - Fills in the template's `{memories}` placeholder\n * - Returns empty string if no memories are provided\n */\nexport function formatMemoryBlock(\n  memories: RecallResult[],\n  template: string,\n  maxTokens: number\n): string {\n  if (memories.length === 0) {\n    return \"\";\n  }\n\n  // Sort by confidence descending; undefined confidence sorts last\n  const sorted = [...memories].sort((a, b) => {\n    const aConf = a.confidence ?? -1;\n    const bConf = b.confidence ?? -1;\n    return bConf - aConf;\n  });\n\n  const maxChars = maxTokens * CHARS_PER_TOKEN;\n  let totalChars = 0;\n  const included: string[] = [];\n\n  for (const memory of sorted) {\n    const line = memory.content;\n    if (totalChars + line.length > maxChars && included.length > 0) {\n      break;\n    }\n    included.push(line);\n    totalChars += line.length;\n  }\n\n  if (included.length === 0) {\n    return \"\";\n  }\n\n  const memoriesText = included.join(\"\\n\");\n  return template.replace(\"{memories}\", () => memoriesText);\n}\n","/**\n * Session mapping strategies.\n *\n * Maps caller identity to Remnic session keys so memory is scoped\n * appropriately per user or shared across all callers.\n */\n\nexport interface ChatCompletionRequest {\n  model?: string;\n  messages?: Array<{ role: string; content: string }>;\n  user?: string;\n  [key: string]: unknown;\n}\n\nexport interface SessionMapper {\n  resolve(\n    headers: Record<string, string | string[] | undefined>,\n    body: ChatCompletionRequest\n  ): string;\n}\n\n/**\n * Returns a fixed session key for single-user setups.\n */\nexport class SingleSessionMapper implements SessionMapper {\n  private readonly key: string;\n\n  constructor(key = \"weclone-default\") {\n    this.key = key;\n  }\n\n  resolve(\n    _headers: Record<string, string | string[] | undefined>,\n    _body: ChatCompletionRequest\n  ): string {\n    return this.key;\n  }\n}\n\n/**\n * Extracts caller identity from request metadata.\n *\n * Resolution order:\n * 1. `X-Caller-Id` header\n * 2. `user` field in the request body\n * 3. Falls back to \"default\"\n */\nexport class CallerIdSessionMapper implements SessionMapper {\n  private readonly fallback: string;\n\n  constructor(fallback = \"default\") {\n    this.fallback = fallback;\n  }\n\n  resolve(\n    headers: Record<string, string | string[] | undefined>,\n    body: ChatCompletionRequest\n  ): string {\n    const headerValue = headers[\"x-caller-id\"];\n    if (typeof headerValue === \"string\" && headerValue.length > 0) {\n      return headerValue;\n    }\n\n    if (typeof body.user === \"string\" && body.user.length > 0) {\n      return body.user;\n    }\n\n    return this.fallback;\n  }\n}\n","/**\n * OpenAI-compatible HTTP proxy for WeClone with Remnic memory injection.\n *\n * Intercepts POST /v1/chat/completions to inject recalled memories,\n * forwards all other requests transparently to the WeClone API.\n */\n\nimport * as http from \"node:http\";\nimport type { WeCloneConnectorConfig } from \"./config.js\";\nimport { formatMemoryBlock, type RecallResult } from \"./format.js\";\nimport {\n  SingleSessionMapper,\n  CallerIdSessionMapper,\n  type SessionMapper,\n  type ChatCompletionRequest,\n} from \"./session.js\";\n\nexport interface WeCloneProxy {\n  start(): Promise<void>;\n  stop(): Promise<void>;\n  port: number;\n}\n\n/**\n * Read the entire body of an IncomingMessage as a string (UTF-8).\n * Used for paths that need to parse JSON (e.g. chat completions).\n */\nfunction readBody(req: http.IncomingMessage): Promise<string> {\n  return new Promise((resolve, reject) => {\n    const chunks: Buffer[] = [];\n    req.on(\"data\", (chunk: Buffer) => chunks.push(chunk));\n    req.on(\"end\", () => resolve(Buffer.concat(chunks).toString(\"utf-8\")));\n    req.on(\"error\", reject);\n  });\n}\n\n/**\n * Read the entire body of an IncomingMessage as raw bytes.\n * Used for the transparent proxy path to avoid corrupting binary/multipart uploads.\n */\nfunction readRawBody(req: http.IncomingMessage): Promise<Buffer> {\n  return new Promise((resolve, reject) => {\n    const chunks: Buffer[] = [];\n    req.on(\"data\", (chunk: Buffer) => chunks.push(chunk));\n    req.on(\"end\", () => resolve(Buffer.concat(chunks)));\n    req.on(\"error\", reject);\n  });\n}\n\n/**\n * Build a flat headers record from IncomingHttpHeaders,\n * normalizing array values to comma-separated strings.\n */\nfunction flattenHeaders(\n  raw: http.IncomingHttpHeaders\n): Record<string, string> {\n  const result: Record<string, string> = {};\n  for (const [key, val] of Object.entries(raw)) {\n    if (val === undefined) continue;\n    result[key] = Array.isArray(val) ? val.join(\", \") : val;\n  }\n  return result;\n}\n\n/**\n * Build standard headers for Remnic daemon requests.\n * Includes Authorization if an auth token is configured.\n */\nfunction remnicHeaders(authToken?: string): Record<string, string> {\n  const headers: Record<string, string> = { \"Content-Type\": \"application/json\" };\n  if (authToken) {\n    headers[\"Authorization\"] = `Bearer ${authToken}`;\n  }\n  return headers;\n}\n\n/**\n * Call Remnic daemon recall endpoint for the given session and query.\n */\nasync function recallMemories(\n  daemonUrl: string,\n  sessionKey: string,\n  query: string,\n  authToken?: string\n): Promise<RecallResult[]> {\n  const url = `${daemonUrl}/engram/v1/recall`;\n  const res = await fetch(url, {\n    method: \"POST\",\n    headers: remnicHeaders(authToken),\n    body: JSON.stringify({ sessionKey, query }),\n  });\n\n  if (!res.ok) {\n    throw new Error(`Remnic recall returned ${res.status}: ${await res.text()}`);\n  }\n\n  const data = (await res.json()) as { results?: Array<{ preview?: string; content?: string; confidence?: number; category?: string }> };\n  const memories: RecallResult[] = (data.results ?? []).map((r) => ({\n    content: r.preview || r.content || \"\",\n    confidence: r.confidence,\n    category: r.category,\n  }));\n  return memories;\n}\n\n/**\n * Fire-and-forget observation to the Remnic daemon.\n * Errors are caught and silently discarded to avoid adding latency.\n */\nfunction observeTurn(\n  daemonUrl: string,\n  sessionKey: string,\n  userMessage: string,\n  assistantMessage: string,\n  authToken?: string\n): void {\n  const url = `${daemonUrl}/engram/v1/observe`;\n  fetch(url, {\n    method: \"POST\",\n    headers: remnicHeaders(authToken),\n    body: JSON.stringify({\n      sessionKey,\n      messages: [\n        { role: \"user\", content: userMessage },\n        { role: \"assistant\", content: assistantMessage },\n      ],\n    }),\n  }).catch(() => {\n    // Intentionally swallowed -- observation must not affect the response path\n  });\n}\n\n/**\n * Coerce an OpenAI chat message `content` into a plain text string.\n *\n * OpenAI chat messages can be either a string or an array of content\n * parts (e.g. `[{type:\"text\",text:\"...\"},{type:\"image_url\",...}]`) for\n * multimodal inputs. Recall/observe only operate on text, so we extract\n * and concatenate the `text` parts. Returns an empty string if no text\n * is present (e.g. image-only turn) so we skip recall rather than sending\n * non-string payloads to the Remnic daemon.\n */\nfunction extractTextContent(content: unknown): string {\n  if (typeof content === \"string\") return content;\n  if (!Array.isArray(content)) return \"\";\n  const parts: string[] = [];\n  for (const part of content) {\n    if (\n      part &&\n      typeof part === \"object\" &&\n      (part as { type?: unknown }).type === \"text\"\n    ) {\n      const text = (part as { text?: unknown }).text;\n      if (typeof text === \"string\") parts.push(text);\n    }\n  }\n  return parts.join(\"\\n\");\n}\n\n/**\n * Extract the last user message's text content from a chat completion\n * messages array. Handles both string and multimodal array content.\n */\nfunction lastUserMessage(messages: Array<{ role: string; content: unknown }>): string {\n  for (let i = messages.length - 1; i >= 0; i--) {\n    if (messages[i].role === \"user\") {\n      return extractTextContent(messages[i].content);\n    }\n  }\n  return \"\";\n}\n\n/**\n * Extract the assistant reply from a WeClone chat completion response.\n */\nfunction extractAssistantReply(responseBody: Record<string, unknown>): string {\n  const choices = responseBody.choices as\n    | Array<{ message?: { content?: string } }>\n    | undefined;\n  if (choices && choices.length > 0) {\n    return choices[0]?.message?.content ?? \"\";\n  }\n  return \"\";\n}\n\n/**\n * Strip trailing slashes from a URL without using a regex quantifier\n * on the same character, which CodeQL flags as polynomial ReDoS\n * (`js/polynomial-redos`). A simple loop is O(n) and cannot backtrack.\n */\nfunction stripTrailingSlashes(s: string): string {\n  let end = s.length;\n  while (end > 0 && s.charCodeAt(end - 1) === 47 /* '/' */) {\n    end--;\n  }\n  return end === s.length ? s : s.slice(0, end);\n}\n\n/**\n * Parse a URL string into { origin, basePath } where `basePath` is the\n * configured path prefix (e.g. \"/weclone/v1\") with any trailing slashes\n * stripped. Falls back safely for malformed inputs.\n */\nfunction splitBaseUrl(urlStr: string): { origin: string; basePath: string } {\n  try {\n    const parsed = new URL(urlStr);\n    const basePath = stripTrailingSlashes(parsed.pathname);\n    return { origin: parsed.origin, basePath };\n  } catch {\n    // Fallback: strip trailing path components without ReDoS-prone regex.\n    // Split on the first \"/\" after the scheme.\n    const schemeEnd = urlStr.indexOf(\"://\");\n    if (schemeEnd === -1) {\n      return { origin: stripTrailingSlashes(urlStr), basePath: \"\" };\n    }\n    const afterScheme = urlStr.slice(schemeEnd + 3);\n    const pathStart = afterScheme.indexOf(\"/\");\n    if (pathStart === -1) {\n      return { origin: urlStr, basePath: \"\" };\n    }\n    const origin = urlStr.slice(0, schemeEnd + 3 + pathStart);\n    const basePath = stripTrailingSlashes(afterScheme.slice(pathStart));\n    return { origin, basePath };\n  }\n}\n\n/**\n * Hop-by-hop request headers that must not be forwarded to upstream.\n * Per RFC 2616 §13.5.1 / RFC 7230 §6.1 these apply only to the\n * immediate transport connection. `proxy-authorization` is the most\n * critical — leaking it would send proxy credentials to the origin.\n *\n * `host` is deliberately excluded from this set because it is\n * always replaced (not just stripped) with the upstream origin\n * and is handled separately below.\n */\nconst HOP_BY_HOP_REQUEST_HEADERS = new Set([\n  \"connection\",\n  \"keep-alive\",\n  \"proxy-authenticate\",\n  \"proxy-authorization\",\n  \"te\",\n  \"trailer\",\n  \"transfer-encoding\",\n  \"upgrade\",\n]);\n\n/**\n * Headers that must not be forwarded from the upstream response.\n * These are hop-by-hop headers that apply to a single transport connection\n * and would conflict with our fully-buffered response write.\n *\n * `content-encoding` is included because fetch() auto-decompresses the body.\n * When we buffer with arrayBuffer() and relay, the bytes are already decoded;\n * forwarding `content-encoding: gzip` would label decompressed bytes as gzip.\n */\nconst HOP_BY_HOP_RESPONSE_HEADERS = new Set([\n  \"transfer-encoding\",\n  \"content-encoding\",\n  \"connection\",\n  \"keep-alive\",\n  \"upgrade\",\n  \"proxy-authenticate\",\n  \"proxy-authorization\",\n  \"te\",\n  \"trailer\",\n]);\n\n/**\n * Forward a request transparently to the WeClone API.\n *\n * If the configured WeClone URL has a non-empty base path (e.g.\n * \"https://host/weclone/v1\"), the proxy forwards incoming request paths\n * such that \"/v1/models\" maps to \"https://host/weclone/v1/models\". For\n * URLs without a base path, paths map 1:1 to the upstream origin.\n *\n * The request body (if any) is forwarded as raw bytes via Uint8Array so\n * that multipart/binary uploads are not corrupted.\n *\n * Reads the full upstream response before writing to the client\n * to avoid partial-header or hanging-body issues.\n */\nasync function transparentProxy(\n  weclone: { origin: string; basePath: string },\n  method: string,\n  path: string,\n  headers: Record<string, string>,\n  body: Buffer | null,\n  res: http.ServerResponse\n): Promise<void> {\n  // Map the client-facing path into an upstream path.\n  //\n  // The proxy exposes an OpenAI-compatible `/v1/...` surface. When the\n  // configured `wecloneApiUrl` itself already ends in `/v1` (or any\n  // path prefix), treat the configured prefix as the upstream mount\n  // point and rewrite `/v1/<rest>` to `<basePath>/<rest>`.\n  //\n  // - basePath \"\" (no prefix): forward path as-is.\n  // - basePath \"/v1\": \"/v1/models\" -> \"/v1/models\" (no change).\n  // - basePath \"/weclone/v1\": \"/v1/models\" -> \"/weclone/v1/models\".\n  //\n  // Split off any query string so rewriting operates on the pathname only.\n  const qIdx = path.indexOf(\"?\");\n  const rawPath = qIdx === -1 ? path : path.slice(0, qIdx);\n  const querySuffix = qIdx === -1 ? \"\" : path.slice(qIdx);\n  let upstreamPathname = rawPath;\n  if (weclone.basePath.length > 0) {\n    if (rawPath === \"/v1\" || rawPath.startsWith(\"/v1/\")) {\n      upstreamPathname = `${weclone.basePath}${rawPath.slice(3)}`;\n    } else if (!rawPath.startsWith(weclone.basePath)) {\n      upstreamPathname = `${weclone.basePath}${rawPath}`;\n    }\n  }\n  const targetUrl = `${weclone.origin}${upstreamPathname}${querySuffix}`;\n\n  // Remove hop-by-hop request headers and replace host with upstream origin\n  const forwardHeaders: Record<string, string> = {};\n  for (const [key, value] of Object.entries(headers)) {\n    if (key === \"host\" || HOP_BY_HOP_REQUEST_HEADERS.has(key)) continue;\n    // content-length is recomputed by fetch() for the forwarded body\n    if (key === \"content-length\") continue;\n    forwardHeaders[key] = value;\n  }\n\n  const fetchInit: RequestInit = {\n    method,\n    headers: forwardHeaders,\n  };\n  if (body && method !== \"GET\" && method !== \"HEAD\") {\n    // Copy into a plain ArrayBuffer so the forwarded request keeps the exact\n    // byte payload while remaining compatible with this package's BodyInit\n    // typing during declaration builds.\n    const rawBody = new ArrayBuffer(body.byteLength);\n    new Uint8Array(rawBody).set(body);\n    fetchInit.body = rawBody;\n  }\n\n  try {\n    const upstream = await fetch(targetUrl, fetchInit);\n\n    // Read full body before sending any headers to the client\n    const responseBody = await upstream.arrayBuffer();\n    const responseBuffer = Buffer.from(responseBody);\n\n    // Build response headers, filtering hop-by-hop and setting Content-Length\n    const responseHeaders: Record<string, string> = {};\n    for (const [key, value] of upstream.headers.entries()) {\n      if (!HOP_BY_HOP_RESPONSE_HEADERS.has(key.toLowerCase())) {\n        responseHeaders[key] = value;\n      }\n    }\n    responseHeaders[\"content-length\"] = String(responseBuffer.length);\n\n    res.writeHead(upstream.status, responseHeaders);\n    res.end(responseBuffer);\n  } catch (_err) {\n    res.writeHead(502, { \"Content-Type\": \"application/json\" });\n    res.end(JSON.stringify({ error: \"upstream_unreachable\" }));\n  }\n}\n\n/**\n * Create a WeClone proxy instance.\n */\nexport function createWeCloneProxy(config: WeCloneConnectorConfig): WeCloneProxy {\n  // Normalize upstream URLs: strip trailing slashes to prevent double-slash\n  // when appending path segments. Use a loop (not regex) to avoid the\n  // polynomial-ReDoS class flagged by CodeQL for `/\\/+$/`.\n  const wecloneApiUrl = stripTrailingSlashes(config.wecloneApiUrl);\n  const remnicDaemonUrl = stripTrailingSlashes(config.remnicDaemonUrl);\n  // Pre-split the WeClone URL so transparentProxy and the chat path can\n  // honor a configured base path (e.g. \"/weclone/v1\").\n  const wecloneParts = splitBaseUrl(wecloneApiUrl);\n\n  const sessionMapper: SessionMapper =\n    config.sessionStrategy === \"caller-id\"\n      ? new CallerIdSessionMapper()\n      : new SingleSessionMapper();\n\n  let server: http.Server | null = null;\n  let resolvedPort = config.proxyPort;\n\n  const requestHandler = async (\n    req: http.IncomingMessage,\n    res: http.ServerResponse\n  ): Promise<void> => {\n    const url = req.url ?? \"/\";\n    const method = (req.method ?? \"GET\").toUpperCase();\n\n    // Parse the request URL into a pathname (stripping query string and\n    // normalizing trailing slash). Using pathname for route matching avoids\n    // silently falling through when clients append query params like\n    // `?api-version=2023-05-15` (common with Azure OpenAI-compatible SDKs).\n    let pathname = url;\n    const queryStart = url.indexOf(\"?\");\n    if (queryStart !== -1) pathname = url.slice(0, queryStart);\n    // Normalize trailing slash for route matching only (not for forwarding).\n    const normalizedPathname =\n      pathname.length > 1 && pathname.endsWith(\"/\")\n        ? pathname.slice(0, -1)\n        : pathname;\n\n    // --- Health check ---\n    if (normalizedPathname === \"/health\" && method === \"GET\") {\n      res.writeHead(200, { \"Content-Type\": \"application/json\" });\n      res.end(JSON.stringify({\n        status: \"ok\",\n        wecloneApi: config.wecloneApiUrl,\n      }));\n      return;\n    }\n\n    // --- Chat completions with memory injection ---\n    if (normalizedPathname === \"/v1/chat/completions\" && method === \"POST\") {\n      let bodyStr: string;\n      try {\n        bodyStr = await readBody(req);\n      } catch {\n        res.writeHead(400, { \"Content-Type\": \"application/json\" });\n        res.end(JSON.stringify({ error: \"bad_request\", detail: \"Could not read request body\" }));\n        return;\n      }\n\n      let parsed: ChatCompletionRequest;\n      try {\n        parsed = JSON.parse(bodyStr) as ChatCompletionRequest;\n      } catch {\n        res.writeHead(400, { \"Content-Type\": \"application/json\" });\n        res.end(JSON.stringify({ error: \"bad_request\", detail: \"Invalid JSON body\" }));\n        return;\n      }\n\n      const headers = req.headers as Record<string, string | string[] | undefined>;\n      const sessionKey = sessionMapper.resolve(headers, parsed);\n      // Validate `messages` is an array with object entries before use so\n      // malformed payloads (`messages: \"...\"`, `messages: {}`, etc.) return\n      // a structured 400 instead of surfacing as a 500 internal error.\n      if (parsed.messages !== undefined && !Array.isArray(parsed.messages)) {\n        res.writeHead(400, { \"Content-Type\": \"application/json\" });\n        res.end(\n          JSON.stringify({\n            error: \"bad_request\",\n            detail: \"messages must be an array\",\n          })\n        );\n        return;\n      }\n      // Messages may contain multimodal content-parts arrays; keep them\n      // untyped and validate strings at each use site. Drop entries that\n      // are not plain objects so downstream `.map()` cannot throw.\n      const rawMessages: Array<{ role: string; content: unknown }> = [];\n      for (const raw of parsed.messages ?? []) {\n        if (raw === null || typeof raw !== \"object\") continue;\n        const entry = raw as { role?: unknown; content?: unknown };\n        rawMessages.push({\n          role: typeof entry.role === \"string\" ? entry.role : \"\",\n          content: entry.content,\n        });\n      }\n      const query = lastUserMessage(rawMessages);\n\n      // Recall memories (graceful degradation on failure)\n      let memoryBlock = \"\";\n      if (query.length > 0) {\n        try {\n          const memories = await recallMemories(\n            remnicDaemonUrl,\n            sessionKey,\n            query,\n            config.remnicAuthToken\n          );\n          memoryBlock = formatMemoryBlock(\n            memories,\n            config.memoryInjection.template,\n            config.memoryInjection.maxTokens\n          );\n        } catch {\n          // Remnic recall failed -- proceed without memory injection\n        }\n      }\n\n      // Build the forwarded messages array. Only the *first* system message\n      // is rewritten with injected memory (or, if no system exists, a\n      // synthetic system message is prepended). Subsequent system messages\n      // are forwarded verbatim so distinct system instructions are not\n      // silently overwritten.\n      const outMessages: Array<{ role: string; content: unknown }> = [];\n      const firstSystemIdx = rawMessages.findIndex((m) => m.role === \"system\");\n      const position = config.memoryInjection.position;\n\n      if (memoryBlock.length === 0) {\n        // No memory to inject — forward original messages unchanged.\n        for (const m of rawMessages) outMessages.push(m);\n      } else if (firstSystemIdx === -1) {\n        // No existing system message: prepend a synthetic one.\n        outMessages.push({ role: \"system\", content: memoryBlock });\n        for (const m of rawMessages) outMessages.push(m);\n      } else {\n        for (let i = 0; i < rawMessages.length; i++) {\n          const m = rawMessages[i];\n          if (i === firstSystemIdx) {\n            const existing = extractTextContent(m.content);\n            outMessages.push({\n              role: \"system\",\n              content:\n                position === \"system-prepend\"\n                  ? `${memoryBlock}\\n\\n${existing}`\n                  : `${existing}\\n\\n${memoryBlock}`,\n            });\n          } else {\n            outMessages.push(m);\n          }\n        }\n      }\n\n      const modifiedBody = {\n        ...parsed,\n        messages: outMessages,\n      };\n\n      // Forward to WeClone. If `wecloneApiUrl` has a path prefix (the\n      // common `/v1` or custom mounts like `/weclone/v1`), forward to\n      // `${basePath}/chat/completions`. If the configured URL has no\n      // base path at all, default to the standard OpenAI `/v1/chat/completions`.\n      // Preserve any query string on the incoming request (e.g. Azure's\n      // `?api-version=...`) so version selectors and tenant hints reach\n      // upstream unchanged.\n      const chatBase = wecloneParts.basePath.length > 0\n        ? wecloneParts.basePath\n        : \"/v1\";\n      const qIdx = url.indexOf(\"?\");\n      const querySuffix = qIdx === -1 ? \"\" : url.slice(qIdx);\n      const targetUrl =\n        `${wecloneParts.origin}${chatBase}/chat/completions${querySuffix}`;\n      const forwardHeaders: Record<string, string> = {\n        \"Content-Type\": \"application/json\",\n      };\n\n      // Preserve authorization if present\n      const authHeader = req.headers[\"authorization\"];\n      if (typeof authHeader === \"string\") {\n        forwardHeaders[\"Authorization\"] = authHeader;\n      }\n\n      try {\n        const upstream = await fetch(targetUrl, {\n          method: \"POST\",\n          headers: forwardHeaders,\n          body: JSON.stringify(modifiedBody),\n        });\n\n        // --- Streaming path ---\n        if (parsed.stream === true) {\n          // If upstream returned an error, pass through as-is (don't force SSE headers)\n          if (!upstream.ok) {\n            const errBody = await upstream.arrayBuffer();\n            res.writeHead(upstream.status, {\n              \"content-type\": upstream.headers.get(\"content-type\") || \"application/json\",\n            });\n            res.end(Buffer.from(errBody));\n            return;\n          }\n\n          res.writeHead(upstream.status, {\n            \"Content-Type\": \"text/event-stream\",\n            \"Cache-Control\": \"no-cache\",\n            \"Connection\": \"keep-alive\",\n          });\n\n          const reader = upstream.body?.getReader();\n          if (!reader) {\n            res.end();\n            return;\n          }\n\n          const chunks: Uint8Array[] = [];\n          try {\n            while (true) {\n              const { done, value } = await reader.read();\n              if (done) break;\n              chunks.push(value);\n              res.write(value);\n            }\n          } finally {\n            res.end();\n          }\n\n          // Best-effort: reconstruct assistant content for observation\n          try {\n            const fullText = Buffer.concat(chunks).toString(\"utf-8\");\n            const contentParts: string[] = [];\n            for (const line of fullText.split(\"\\n\")) {\n              if (!line.startsWith(\"data: \") || line === \"data: [DONE]\") continue;\n              try {\n                const event = JSON.parse(line.slice(6)) as {\n                  choices?: Array<{ delta?: { content?: string } }>;\n                };\n                const delta = event.choices?.[0]?.delta?.content;\n                if (delta) contentParts.push(delta);\n              } catch {\n                // Malformed SSE chunk -- skip\n              }\n            }\n            if (contentParts.length > 0 && query.length > 0) {\n              observeTurn(\n                remnicDaemonUrl,\n                sessionKey,\n                query,\n                contentParts.join(\"\"),\n                config.remnicAuthToken\n              );\n            }\n          } catch {\n            // Observation reconstruction failed -- non-critical\n          }\n          return;\n        }\n\n        // --- Non-streaming path ---\n        const responseBuffer = await upstream.arrayBuffer();\n        const responseBytes = Buffer.from(responseBuffer);\n\n        // Parse response for observation (best-effort)\n        let assistantReply = \"\";\n        try {\n          const responseJson = JSON.parse(\n            responseBytes.toString(\"utf-8\")\n          ) as Record<string, unknown>;\n          assistantReply = extractAssistantReply(responseJson);\n        } catch {\n          // Non-JSON response -- skip observation\n        }\n\n        // Fire-and-forget observe\n        if (query.length > 0 && assistantReply.length > 0) {\n          observeTurn(remnicDaemonUrl, sessionKey, query, assistantReply, config.remnicAuthToken);\n        }\n\n        // Return upstream response to caller, stripping hop-by-hop headers\n        const chatResponseHeaders: Record<string, string> = {};\n        for (const [key, value] of upstream.headers.entries()) {\n          if (!HOP_BY_HOP_RESPONSE_HEADERS.has(key.toLowerCase())) {\n            chatResponseHeaders[key] = value;\n          }\n        }\n        chatResponseHeaders[\"content-length\"] = String(responseBytes.length);\n        res.writeHead(upstream.status, chatResponseHeaders);\n        res.end(responseBytes);\n      } catch (_err) {\n        res.writeHead(502, { \"Content-Type\": \"application/json\" });\n        res.end(JSON.stringify({\n          error: \"upstream_unreachable\",\n        }));\n      }\n      return;\n    }\n\n    // --- All other paths: transparent proxy ---\n    // Use raw bytes to avoid corrupting binary/multipart uploads.\n    const body = method !== \"GET\" && method !== \"HEAD\" ? await readRawBody(req) : null;\n    const flat = flattenHeaders(req.headers);\n    await transparentProxy(wecloneParts, method, url, flat, body, res);\n  };\n\n  return {\n    get port() {\n      return resolvedPort;\n    },\n\n    start(): Promise<void> {\n      return new Promise((resolve, reject) => {\n        server = http.createServer((req, res) => {\n          requestHandler(req, res).catch((_err) => {\n            if (!res.headersSent) {\n              res.writeHead(500, { \"Content-Type\": \"application/json\" });\n              res.end(JSON.stringify({ error: \"internal_proxy_error\" }));\n            }\n          });\n        });\n\n        server.on(\"error\", reject);\n\n        server.listen(config.proxyPort, () => {\n          const addr = server!.address();\n          if (typeof addr === \"object\" && addr !== null) {\n            resolvedPort = addr.port;\n          }\n          resolve();\n        });\n      });\n    },\n\n    stop(): Promise<void> {\n      return new Promise((resolve, reject) => {\n        if (!server) {\n          resolve();\n          return;\n        }\n        server.close((err) => {\n          server = null;\n          if (err) reject(err);\n          else resolve();\n        });\n      });\n    },\n  };\n}\n","/**\n * WeClone connector configuration.\n *\n * Validates user-provided config and applies defaults for optional fields.\n */\n\nexport interface MemoryInjectionConfig {\n  maxTokens: number;\n  position: \"system-append\" | \"system-prepend\";\n  template: string;\n}\n\nexport interface WeCloneConnectorConfig {\n  wecloneApiUrl: string;\n  wecloneModelName?: string;\n  proxyPort: number;\n  remnicDaemonUrl: string;\n  remnicAuthToken?: string;\n  sessionStrategy: \"caller-id\" | \"single\";\n  memoryInjection: MemoryInjectionConfig;\n}\n\nexport const DEFAULT_CONFIG: WeCloneConnectorConfig = {\n  wecloneApiUrl: \"http://localhost:8000/v1\",\n  wecloneModelName: \"weclone-avatar\",\n  proxyPort: 8100,\n  remnicDaemonUrl: \"http://localhost:4318\",\n  sessionStrategy: \"single\",\n  memoryInjection: {\n    maxTokens: 1500,\n    position: \"system-append\",\n    template: \"[Memory Context]\\n{memories}\\n[End Memory Context]\",\n  },\n};\n\nconst VALID_SESSION_STRATEGIES = [\"caller-id\", \"single\"] as const;\nconst VALID_POSITIONS = [\"system-append\", \"system-prepend\"] as const;\n\n/**\n * Parse and validate a raw config object into a WeCloneConnectorConfig.\n *\n * Rejects missing required fields and invalid values with clear messages.\n * Applies defaults for all optional fields.\n */\nexport function parseConfig(raw: unknown): WeCloneConnectorConfig {\n  if (typeof raw !== \"object\" || raw === null) {\n    throw new Error(\"Config must be a non-null object\");\n  }\n\n  const obj = raw as Record<string, unknown>;\n\n  // --- Required fields ---\n  if (typeof obj.wecloneApiUrl !== \"string\" || obj.wecloneApiUrl.length === 0) {\n    throw new Error(\n      \"Config 'wecloneApiUrl' is required and must be a non-empty string\"\n    );\n  }\n\n  if (\n    typeof obj.proxyPort !== \"number\" ||\n    !Number.isInteger(obj.proxyPort) ||\n    obj.proxyPort <= 0 ||\n    obj.proxyPort > 65535\n  ) {\n    throw new Error(\n      \"Config 'proxyPort' is required and must be an integer between 1 and 65535\"\n    );\n  }\n\n  if (typeof obj.remnicDaemonUrl !== \"string\" || obj.remnicDaemonUrl.length === 0) {\n    throw new Error(\n      \"Config 'remnicDaemonUrl' is required and must be a non-empty string\"\n    );\n  }\n\n  // --- Optional fields with validation ---\n  let remnicAuthToken: string | undefined;\n  if (obj.remnicAuthToken !== undefined) {\n    if (typeof obj.remnicAuthToken !== \"string\" || obj.remnicAuthToken.length === 0) {\n      throw new Error(\n        \"Config 'remnicAuthToken' must be a non-empty string when provided\"\n      );\n    }\n    remnicAuthToken = obj.remnicAuthToken;\n  }\n\n  const wecloneModelName =\n    obj.wecloneModelName !== undefined\n      ? String(obj.wecloneModelName)\n      : DEFAULT_CONFIG.wecloneModelName;\n\n  let sessionStrategy = DEFAULT_CONFIG.sessionStrategy;\n  if (obj.sessionStrategy !== undefined) {\n    if (!VALID_SESSION_STRATEGIES.includes(obj.sessionStrategy as typeof VALID_SESSION_STRATEGIES[number])) {\n      throw new Error(\n        `Config 'sessionStrategy' must be one of: ${VALID_SESSION_STRATEGIES.join(\", \")}. ` +\n          `Got: ${JSON.stringify(obj.sessionStrategy)}`\n      );\n    }\n    sessionStrategy = obj.sessionStrategy as typeof sessionStrategy;\n  }\n\n  // --- Memory injection ---\n  let memoryInjection = { ...DEFAULT_CONFIG.memoryInjection };\n  if (obj.memoryInjection !== undefined) {\n    if (typeof obj.memoryInjection !== \"object\" || obj.memoryInjection === null) {\n      throw new Error(\"Config 'memoryInjection' must be an object\");\n    }\n    const mi = obj.memoryInjection as Record<string, unknown>;\n\n    if (mi.maxTokens !== undefined) {\n      if (typeof mi.maxTokens !== \"number\" || !Number.isInteger(mi.maxTokens) || mi.maxTokens <= 0) {\n        throw new Error(\n          \"Config 'memoryInjection.maxTokens' must be a positive integer\"\n        );\n      }\n      memoryInjection.maxTokens = mi.maxTokens;\n    }\n\n    if (mi.position !== undefined) {\n      if (!VALID_POSITIONS.includes(mi.position as typeof VALID_POSITIONS[number])) {\n        throw new Error(\n          `Config 'memoryInjection.position' must be one of: ` +\n            `${VALID_POSITIONS.join(\", \")}. Got: ${JSON.stringify(mi.position)}`\n        );\n      }\n      memoryInjection.position = mi.position as typeof memoryInjection.position;\n    }\n\n    if (mi.template !== undefined) {\n      if (typeof mi.template !== \"string\" || mi.template.length === 0) {\n        throw new Error(\n          \"Config 'memoryInjection.template' must be a non-empty string\"\n        );\n      }\n      memoryInjection.template = mi.template;\n    }\n  }\n\n  return {\n    wecloneApiUrl: obj.wecloneApiUrl,\n    wecloneModelName,\n    proxyPort: obj.proxyPort,\n    remnicDaemonUrl: obj.remnicDaemonUrl,\n    remnicAuthToken,\n    sessionStrategy,\n    memoryInjection,\n  };\n}\n"],"mappings":";;;AAaA,IAAM,kBAAkB;AAUjB,SAAS,kBACd,UACA,UACA,WACQ;AACR,MAAI,SAAS,WAAW,GAAG;AACzB,WAAO;AAAA,EACT;AAGA,QAAM,SAAS,CAAC,GAAG,QAAQ,EAAE,KAAK,CAAC,GAAG,MAAM;AAC1C,UAAM,QAAQ,EAAE,cAAc;AAC9B,UAAM,QAAQ,EAAE,cAAc;AAC9B,WAAO,QAAQ;AAAA,EACjB,CAAC;AAED,QAAM,WAAW,YAAY;AAC7B,MAAI,aAAa;AACjB,QAAM,WAAqB,CAAC;AAE5B,aAAW,UAAU,QAAQ;AAC3B,UAAM,OAAO,OAAO;AACpB,QAAI,aAAa,KAAK,SAAS,YAAY,SAAS,SAAS,GAAG;AAC9D;AAAA,IACF;AACA,aAAS,KAAK,IAAI;AAClB,kBAAc,KAAK;AAAA,EACrB;AAEA,MAAI,SAAS,WAAW,GAAG;AACzB,WAAO;AAAA,EACT;AAEA,QAAM,eAAe,SAAS,KAAK,IAAI;AACvC,SAAO,SAAS,QAAQ,cAAc,MAAM,YAAY;AAC1D;;;AClCO,IAAM,sBAAN,MAAmD;AAAA,EACvC;AAAA,EAEjB,YAAY,MAAM,mBAAmB;AACnC,SAAK,MAAM;AAAA,EACb;AAAA,EAEA,QACE,UACA,OACQ;AACR,WAAO,KAAK;AAAA,EACd;AACF;AAUO,IAAM,wBAAN,MAAqD;AAAA,EACzC;AAAA,EAEjB,YAAY,WAAW,WAAW;AAChC,SAAK,WAAW;AAAA,EAClB;AAAA,EAEA,QACE,SACA,MACQ;AACR,UAAM,cAAc,QAAQ,aAAa;AACzC,QAAI,OAAO,gBAAgB,YAAY,YAAY,SAAS,GAAG;AAC7D,aAAO;AAAA,IACT;AAEA,QAAI,OAAO,KAAK,SAAS,YAAY,KAAK,KAAK,SAAS,GAAG;AACzD,aAAO,KAAK;AAAA,IACd;AAEA,WAAO,KAAK;AAAA,EACd;AACF;;;AC9DA,YAAY,UAAU;AAoBtB,SAAS,SAAS,KAA4C;AAC5D,SAAO,IAAI,QAAQ,CAAC,SAAS,WAAW;AACtC,UAAM,SAAmB,CAAC;AAC1B,QAAI,GAAG,QAAQ,CAAC,UAAkB,OAAO,KAAK,KAAK,CAAC;AACpD,QAAI,GAAG,OAAO,MAAM,QAAQ,OAAO,OAAO,MAAM,EAAE,SAAS,OAAO,CAAC,CAAC;AACpE,QAAI,GAAG,SAAS,MAAM;AAAA,EACxB,CAAC;AACH;AAMA,SAAS,YAAY,KAA4C;AAC/D,SAAO,IAAI,QAAQ,CAAC,SAAS,WAAW;AACtC,UAAM,SAAmB,CAAC;AAC1B,QAAI,GAAG,QAAQ,CAAC,UAAkB,OAAO,KAAK,KAAK,CAAC;AACpD,QAAI,GAAG,OAAO,MAAM,QAAQ,OAAO,OAAO,MAAM,CAAC,CAAC;AAClD,QAAI,GAAG,SAAS,MAAM;AAAA,EACxB,CAAC;AACH;AAMA,SAAS,eACP,KACwB;AACxB,QAAM,SAAiC,CAAC;AACxC,aAAW,CAAC,KAAK,GAAG,KAAK,OAAO,QAAQ,GAAG,GAAG;AAC5C,QAAI,QAAQ,OAAW;AACvB,WAAO,GAAG,IAAI,MAAM,QAAQ,GAAG,IAAI,IAAI,KAAK,IAAI,IAAI;AAAA,EACtD;AACA,SAAO;AACT;AAMA,SAAS,cAAc,WAA4C;AACjE,QAAM,UAAkC,EAAE,gBAAgB,mBAAmB;AAC7E,MAAI,WAAW;AACb,YAAQ,eAAe,IAAI,UAAU,SAAS;AAAA,EAChD;AACA,SAAO;AACT;AAKA,eAAe,eACb,WACA,YACA,OACA,WACyB;AACzB,QAAM,MAAM,GAAG,SAAS;AACxB,QAAM,MAAM,MAAM,MAAM,KAAK;AAAA,IAC3B,QAAQ;AAAA,IACR,SAAS,cAAc,SAAS;AAAA,IAChC,MAAM,KAAK,UAAU,EAAE,YAAY,MAAM,CAAC;AAAA,EAC5C,CAAC;AAED,MAAI,CAAC,IAAI,IAAI;AACX,UAAM,IAAI,MAAM,0BAA0B,IAAI,MAAM,KAAK,MAAM,IAAI,KAAK,CAAC,EAAE;AAAA,EAC7E;AAEA,QAAM,OAAQ,MAAM,IAAI,KAAK;AAC7B,QAAM,YAA4B,KAAK,WAAW,CAAC,GAAG,IAAI,CAAC,OAAO;AAAA,IAChE,SAAS,EAAE,WAAW,EAAE,WAAW;AAAA,IACnC,YAAY,EAAE;AAAA,IACd,UAAU,EAAE;AAAA,EACd,EAAE;AACF,SAAO;AACT;AAMA,SAAS,YACP,WACA,YACA,aACA,kBACA,WACM;AACN,QAAM,MAAM,GAAG,SAAS;AACxB,QAAM,KAAK;AAAA,IACT,QAAQ;AAAA,IACR,SAAS,cAAc,SAAS;AAAA,IAChC,MAAM,KAAK,UAAU;AAAA,MACnB;AAAA,MACA,UAAU;AAAA,QACR,EAAE,MAAM,QAAQ,SAAS,YAAY;AAAA,QACrC,EAAE,MAAM,aAAa,SAAS,iBAAiB;AAAA,MACjD;AAAA,IACF,CAAC;AAAA,EACH,CAAC,EAAE,MAAM,MAAM;AAAA,EAEf,CAAC;AACH;AAYA,SAAS,mBAAmB,SAA0B;AACpD,MAAI,OAAO,YAAY,SAAU,QAAO;AACxC,MAAI,CAAC,MAAM,QAAQ,OAAO,EAAG,QAAO;AACpC,QAAM,QAAkB,CAAC;AACzB,aAAW,QAAQ,SAAS;AAC1B,QACE,QACA,OAAO,SAAS,YACf,KAA4B,SAAS,QACtC;AACA,YAAM,OAAQ,KAA4B;AAC1C,UAAI,OAAO,SAAS,SAAU,OAAM,KAAK,IAAI;AAAA,IAC/C;AAAA,EACF;AACA,SAAO,MAAM,KAAK,IAAI;AACxB;AAMA,SAAS,gBAAgB,UAA6D;AACpF,WAAS,IAAI,SAAS,SAAS,GAAG,KAAK,GAAG,KAAK;AAC7C,QAAI,SAAS,CAAC,EAAE,SAAS,QAAQ;AAC/B,aAAO,mBAAmB,SAAS,CAAC,EAAE,OAAO;AAAA,IAC/C;AAAA,EACF;AACA,SAAO;AACT;AAKA,SAAS,sBAAsB,cAA+C;AAC5E,QAAM,UAAU,aAAa;AAG7B,MAAI,WAAW,QAAQ,SAAS,GAAG;AACjC,WAAO,QAAQ,CAAC,GAAG,SAAS,WAAW;AAAA,EACzC;AACA,SAAO;AACT;AAOA,SAAS,qBAAqB,GAAmB;AAC/C,MAAI,MAAM,EAAE;AACZ,SAAO,MAAM,KAAK,EAAE,WAAW,MAAM,CAAC,MAAM,IAAc;AACxD;AAAA,EACF;AACA,SAAO,QAAQ,EAAE,SAAS,IAAI,EAAE,MAAM,GAAG,GAAG;AAC9C;AAOA,SAAS,aAAa,QAAsD;AAC1E,MAAI;AACF,UAAM,SAAS,IAAI,IAAI,MAAM;AAC7B,UAAM,WAAW,qBAAqB,OAAO,QAAQ;AACrD,WAAO,EAAE,QAAQ,OAAO,QAAQ,SAAS;AAAA,EAC3C,QAAQ;AAGN,UAAM,YAAY,OAAO,QAAQ,KAAK;AACtC,QAAI,cAAc,IAAI;AACpB,aAAO,EAAE,QAAQ,qBAAqB,MAAM,GAAG,UAAU,GAAG;AAAA,IAC9D;AACA,UAAM,cAAc,OAAO,MAAM,YAAY,CAAC;AAC9C,UAAM,YAAY,YAAY,QAAQ,GAAG;AACzC,QAAI,cAAc,IAAI;AACpB,aAAO,EAAE,QAAQ,QAAQ,UAAU,GAAG;AAAA,IACxC;AACA,UAAM,SAAS,OAAO,MAAM,GAAG,YAAY,IAAI,SAAS;AACxD,UAAM,WAAW,qBAAqB,YAAY,MAAM,SAAS,CAAC;AAClE,WAAO,EAAE,QAAQ,SAAS;AAAA,EAC5B;AACF;AAYA,IAAM,6BAA6B,oBAAI,IAAI;AAAA,EACzC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,CAAC;AAWD,IAAM,8BAA8B,oBAAI,IAAI;AAAA,EAC1C;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,CAAC;AAgBD,eAAe,iBACb,SACA,QACA,MACA,SACA,MACA,KACe;AAaf,QAAM,OAAO,KAAK,QAAQ,GAAG;AAC7B,QAAM,UAAU,SAAS,KAAK,OAAO,KAAK,MAAM,GAAG,IAAI;AACvD,QAAM,cAAc,SAAS,KAAK,KAAK,KAAK,MAAM,IAAI;AACtD,MAAI,mBAAmB;AACvB,MAAI,QAAQ,SAAS,SAAS,GAAG;AAC/B,QAAI,YAAY,SAAS,QAAQ,WAAW,MAAM,GAAG;AACnD,yBAAmB,GAAG,QAAQ,QAAQ,GAAG,QAAQ,MAAM,CAAC,CAAC;AAAA,IAC3D,WAAW,CAAC,QAAQ,WAAW,QAAQ,QAAQ,GAAG;AAChD,yBAAmB,GAAG,QAAQ,QAAQ,GAAG,OAAO;AAAA,IAClD;AAAA,EACF;AACA,QAAM,YAAY,GAAG,QAAQ,MAAM,GAAG,gBAAgB,GAAG,WAAW;AAGpE,QAAM,iBAAyC,CAAC;AAChD,aAAW,CAAC,KAAK,KAAK,KAAK,OAAO,QAAQ,OAAO,GAAG;AAClD,QAAI,QAAQ,UAAU,2BAA2B,IAAI,GAAG,EAAG;AAE3D,QAAI,QAAQ,iBAAkB;AAC9B,mBAAe,GAAG,IAAI;AAAA,EACxB;AAEA,QAAM,YAAyB;AAAA,IAC7B;AAAA,IACA,SAAS;AAAA,EACX;AACA,MAAI,QAAQ,WAAW,SAAS,WAAW,QAAQ;AAIjD,UAAM,UAAU,IAAI,YAAY,KAAK,UAAU;AAC/C,QAAI,WAAW,OAAO,EAAE,IAAI,IAAI;AAChC,cAAU,OAAO;AAAA,EACnB;AAEA,MAAI;AACF,UAAM,WAAW,MAAM,MAAM,WAAW,SAAS;AAGjD,UAAM,eAAe,MAAM,SAAS,YAAY;AAChD,UAAM,iBAAiB,OAAO,KAAK,YAAY;AAG/C,UAAM,kBAA0C,CAAC;AACjD,eAAW,CAAC,KAAK,KAAK,KAAK,SAAS,QAAQ,QAAQ,GAAG;AACrD,UAAI,CAAC,4BAA4B,IAAI,IAAI,YAAY,CAAC,GAAG;AACvD,wBAAgB,GAAG,IAAI;AAAA,MACzB;AAAA,IACF;AACA,oBAAgB,gBAAgB,IAAI,OAAO,eAAe,MAAM;AAEhE,QAAI,UAAU,SAAS,QAAQ,eAAe;AAC9C,QAAI,IAAI,cAAc;AAAA,EACxB,SAAS,MAAM;AACb,QAAI,UAAU,KAAK,EAAE,gBAAgB,mBAAmB,CAAC;AACzD,QAAI,IAAI,KAAK,UAAU,EAAE,OAAO,uBAAuB,CAAC,CAAC;AAAA,EAC3D;AACF;AAKO,SAAS,mBAAmB,QAA8C;AAI/E,QAAM,gBAAgB,qBAAqB,OAAO,aAAa;AAC/D,QAAM,kBAAkB,qBAAqB,OAAO,eAAe;AAGnE,QAAM,eAAe,aAAa,aAAa;AAE/C,QAAM,gBACJ,OAAO,oBAAoB,cACvB,IAAI,sBAAsB,IAC1B,IAAI,oBAAoB;AAE9B,MAAI,SAA6B;AACjC,MAAI,eAAe,OAAO;AAE1B,QAAM,iBAAiB,OACrB,KACA,QACkB;AAClB,UAAM,MAAM,IAAI,OAAO;AACvB,UAAM,UAAU,IAAI,UAAU,OAAO,YAAY;AAMjD,QAAI,WAAW;AACf,UAAM,aAAa,IAAI,QAAQ,GAAG;AAClC,QAAI,eAAe,GAAI,YAAW,IAAI,MAAM,GAAG,UAAU;AAEzD,UAAM,qBACJ,SAAS,SAAS,KAAK,SAAS,SAAS,GAAG,IACxC,SAAS,MAAM,GAAG,EAAE,IACpB;AAGN,QAAI,uBAAuB,aAAa,WAAW,OAAO;AACxD,UAAI,UAAU,KAAK,EAAE,gBAAgB,mBAAmB,CAAC;AACzD,UAAI,IAAI,KAAK,UAAU;AAAA,QACrB,QAAQ;AAAA,QACR,YAAY,OAAO;AAAA,MACrB,CAAC,CAAC;AACF;AAAA,IACF;AAGA,QAAI,uBAAuB,0BAA0B,WAAW,QAAQ;AACtE,UAAI;AACJ,UAAI;AACF,kBAAU,MAAM,SAAS,GAAG;AAAA,MAC9B,QAAQ;AACN,YAAI,UAAU,KAAK,EAAE,gBAAgB,mBAAmB,CAAC;AACzD,YAAI,IAAI,KAAK,UAAU,EAAE,OAAO,eAAe,QAAQ,8BAA8B,CAAC,CAAC;AACvF;AAAA,MACF;AAEA,UAAI;AACJ,UAAI;AACF,iBAAS,KAAK,MAAM,OAAO;AAAA,MAC7B,QAAQ;AACN,YAAI,UAAU,KAAK,EAAE,gBAAgB,mBAAmB,CAAC;AACzD,YAAI,IAAI,KAAK,UAAU,EAAE,OAAO,eAAe,QAAQ,oBAAoB,CAAC,CAAC;AAC7E;AAAA,MACF;AAEA,YAAM,UAAU,IAAI;AACpB,YAAM,aAAa,cAAc,QAAQ,SAAS,MAAM;AAIxD,UAAI,OAAO,aAAa,UAAa,CAAC,MAAM,QAAQ,OAAO,QAAQ,GAAG;AACpE,YAAI,UAAU,KAAK,EAAE,gBAAgB,mBAAmB,CAAC;AACzD,YAAI;AAAA,UACF,KAAK,UAAU;AAAA,YACb,OAAO;AAAA,YACP,QAAQ;AAAA,UACV,CAAC;AAAA,QACH;AACA;AAAA,MACF;AAIA,YAAM,cAAyD,CAAC;AAChE,iBAAW,OAAO,OAAO,YAAY,CAAC,GAAG;AACvC,YAAI,QAAQ,QAAQ,OAAO,QAAQ,SAAU;AAC7C,cAAM,QAAQ;AACd,oBAAY,KAAK;AAAA,UACf,MAAM,OAAO,MAAM,SAAS,WAAW,MAAM,OAAO;AAAA,UACpD,SAAS,MAAM;AAAA,QACjB,CAAC;AAAA,MACH;AACA,YAAM,QAAQ,gBAAgB,WAAW;AAGzC,UAAI,cAAc;AAClB,UAAI,MAAM,SAAS,GAAG;AACpB,YAAI;AACF,gBAAM,WAAW,MAAM;AAAA,YACrB;AAAA,YACA;AAAA,YACA;AAAA,YACA,OAAO;AAAA,UACT;AACA,wBAAc;AAAA,YACZ;AAAA,YACA,OAAO,gBAAgB;AAAA,YACvB,OAAO,gBAAgB;AAAA,UACzB;AAAA,QACF,QAAQ;AAAA,QAER;AAAA,MACF;AAOA,YAAM,cAAyD,CAAC;AAChE,YAAM,iBAAiB,YAAY,UAAU,CAAC,MAAM,EAAE,SAAS,QAAQ;AACvE,YAAM,WAAW,OAAO,gBAAgB;AAExC,UAAI,YAAY,WAAW,GAAG;AAE5B,mBAAW,KAAK,YAAa,aAAY,KAAK,CAAC;AAAA,MACjD,WAAW,mBAAmB,IAAI;AAEhC,oBAAY,KAAK,EAAE,MAAM,UAAU,SAAS,YAAY,CAAC;AACzD,mBAAW,KAAK,YAAa,aAAY,KAAK,CAAC;AAAA,MACjD,OAAO;AACL,iBAAS,IAAI,GAAG,IAAI,YAAY,QAAQ,KAAK;AAC3C,gBAAM,IAAI,YAAY,CAAC;AACvB,cAAI,MAAM,gBAAgB;AACxB,kBAAM,WAAW,mBAAmB,EAAE,OAAO;AAC7C,wBAAY,KAAK;AAAA,cACf,MAAM;AAAA,cACN,SACE,aAAa,mBACT,GAAG,WAAW;AAAA;AAAA,EAAO,QAAQ,KAC7B,GAAG,QAAQ;AAAA;AAAA,EAAO,WAAW;AAAA,YACrC,CAAC;AAAA,UACH,OAAO;AACL,wBAAY,KAAK,CAAC;AAAA,UACpB;AAAA,QACF;AAAA,MACF;AAEA,YAAM,eAAe;AAAA,QACnB,GAAG;AAAA,QACH,UAAU;AAAA,MACZ;AASA,YAAM,WAAW,aAAa,SAAS,SAAS,IAC5C,aAAa,WACb;AACJ,YAAM,OAAO,IAAI,QAAQ,GAAG;AAC5B,YAAM,cAAc,SAAS,KAAK,KAAK,IAAI,MAAM,IAAI;AACrD,YAAM,YACJ,GAAG,aAAa,MAAM,GAAG,QAAQ,oBAAoB,WAAW;AAClE,YAAM,iBAAyC;AAAA,QAC7C,gBAAgB;AAAA,MAClB;AAGA,YAAM,aAAa,IAAI,QAAQ,eAAe;AAC9C,UAAI,OAAO,eAAe,UAAU;AAClC,uBAAe,eAAe,IAAI;AAAA,MACpC;AAEA,UAAI;AACF,cAAM,WAAW,MAAM,MAAM,WAAW;AAAA,UACtC,QAAQ;AAAA,UACR,SAAS;AAAA,UACT,MAAM,KAAK,UAAU,YAAY;AAAA,QACnC,CAAC;AAGD,YAAI,OAAO,WAAW,MAAM;AAE1B,cAAI,CAAC,SAAS,IAAI;AAChB,kBAAM,UAAU,MAAM,SAAS,YAAY;AAC3C,gBAAI,UAAU,SAAS,QAAQ;AAAA,cAC7B,gBAAgB,SAAS,QAAQ,IAAI,cAAc,KAAK;AAAA,YAC1D,CAAC;AACD,gBAAI,IAAI,OAAO,KAAK,OAAO,CAAC;AAC5B;AAAA,UACF;AAEA,cAAI,UAAU,SAAS,QAAQ;AAAA,YAC7B,gBAAgB;AAAA,YAChB,iBAAiB;AAAA,YACjB,cAAc;AAAA,UAChB,CAAC;AAED,gBAAM,SAAS,SAAS,MAAM,UAAU;AACxC,cAAI,CAAC,QAAQ;AACX,gBAAI,IAAI;AACR;AAAA,UACF;AAEA,gBAAM,SAAuB,CAAC;AAC9B,cAAI;AACF,mBAAO,MAAM;AACX,oBAAM,EAAE,MAAM,MAAM,IAAI,MAAM,OAAO,KAAK;AAC1C,kBAAI,KAAM;AACV,qBAAO,KAAK,KAAK;AACjB,kBAAI,MAAM,KAAK;AAAA,YACjB;AAAA,UACF,UAAE;AACA,gBAAI,IAAI;AAAA,UACV;AAGA,cAAI;AACF,kBAAM,WAAW,OAAO,OAAO,MAAM,EAAE,SAAS,OAAO;AACvD,kBAAM,eAAyB,CAAC;AAChC,uBAAW,QAAQ,SAAS,MAAM,IAAI,GAAG;AACvC,kBAAI,CAAC,KAAK,WAAW,QAAQ,KAAK,SAAS,eAAgB;AAC3D,kBAAI;AACF,sBAAM,QAAQ,KAAK,MAAM,KAAK,MAAM,CAAC,CAAC;AAGtC,sBAAM,QAAQ,MAAM,UAAU,CAAC,GAAG,OAAO;AACzC,oBAAI,MAAO,cAAa,KAAK,KAAK;AAAA,cACpC,QAAQ;AAAA,cAER;AAAA,YACF;AACA,gBAAI,aAAa,SAAS,KAAK,MAAM,SAAS,GAAG;AAC/C;AAAA,gBACE;AAAA,gBACA;AAAA,gBACA;AAAA,gBACA,aAAa,KAAK,EAAE;AAAA,gBACpB,OAAO;AAAA,cACT;AAAA,YACF;AAAA,UACF,QAAQ;AAAA,UAER;AACA;AAAA,QACF;AAGA,cAAM,iBAAiB,MAAM,SAAS,YAAY;AAClD,cAAM,gBAAgB,OAAO,KAAK,cAAc;AAGhD,YAAI,iBAAiB;AACrB,YAAI;AACF,gBAAM,eAAe,KAAK;AAAA,YACxB,cAAc,SAAS,OAAO;AAAA,UAChC;AACA,2BAAiB,sBAAsB,YAAY;AAAA,QACrD,QAAQ;AAAA,QAER;AAGA,YAAI,MAAM,SAAS,KAAK,eAAe,SAAS,GAAG;AACjD,sBAAY,iBAAiB,YAAY,OAAO,gBAAgB,OAAO,eAAe;AAAA,QACxF;AAGA,cAAM,sBAA8C,CAAC;AACrD,mBAAW,CAAC,KAAK,KAAK,KAAK,SAAS,QAAQ,QAAQ,GAAG;AACrD,cAAI,CAAC,4BAA4B,IAAI,IAAI,YAAY,CAAC,GAAG;AACvD,gCAAoB,GAAG,IAAI;AAAA,UAC7B;AAAA,QACF;AACA,4BAAoB,gBAAgB,IAAI,OAAO,cAAc,MAAM;AACnE,YAAI,UAAU,SAAS,QAAQ,mBAAmB;AAClD,YAAI,IAAI,aAAa;AAAA,MACvB,SAAS,MAAM;AACb,YAAI,UAAU,KAAK,EAAE,gBAAgB,mBAAmB,CAAC;AACzD,YAAI,IAAI,KAAK,UAAU;AAAA,UACrB,OAAO;AAAA,QACT,CAAC,CAAC;AAAA,MACJ;AACA;AAAA,IACF;AAIA,UAAM,OAAO,WAAW,SAAS,WAAW,SAAS,MAAM,YAAY,GAAG,IAAI;AAC9E,UAAM,OAAO,eAAe,IAAI,OAAO;AACvC,UAAM,iBAAiB,cAAc,QAAQ,KAAK,MAAM,MAAM,GAAG;AAAA,EACnE;AAEA,SAAO;AAAA,IACL,IAAI,OAAO;AACT,aAAO;AAAA,IACT;AAAA,IAEA,QAAuB;AACrB,aAAO,IAAI,QAAQ,CAAC,SAAS,WAAW;AACtC,iBAAc,kBAAa,CAAC,KAAK,QAAQ;AACvC,yBAAe,KAAK,GAAG,EAAE,MAAM,CAAC,SAAS;AACvC,gBAAI,CAAC,IAAI,aAAa;AACpB,kBAAI,UAAU,KAAK,EAAE,gBAAgB,mBAAmB,CAAC;AACzD,kBAAI,IAAI,KAAK,UAAU,EAAE,OAAO,uBAAuB,CAAC,CAAC;AAAA,YAC3D;AAAA,UACF,CAAC;AAAA,QACH,CAAC;AAED,eAAO,GAAG,SAAS,MAAM;AAEzB,eAAO,OAAO,OAAO,WAAW,MAAM;AACpC,gBAAM,OAAO,OAAQ,QAAQ;AAC7B,cAAI,OAAO,SAAS,YAAY,SAAS,MAAM;AAC7C,2BAAe,KAAK;AAAA,UACtB;AACA,kBAAQ;AAAA,QACV,CAAC;AAAA,MACH,CAAC;AAAA,IACH;AAAA,IAEA,OAAsB;AACpB,aAAO,IAAI,QAAQ,CAAC,SAAS,WAAW;AACtC,YAAI,CAAC,QAAQ;AACX,kBAAQ;AACR;AAAA,QACF;AACA,eAAO,MAAM,CAAC,QAAQ;AACpB,mBAAS;AACT,cAAI,IAAK,QAAO,GAAG;AAAA,cACd,SAAQ;AAAA,QACf,CAAC;AAAA,MACH,CAAC;AAAA,IACH;AAAA,EACF;AACF;;;AC5qBO,IAAM,iBAAyC;AAAA,EACpD,eAAe;AAAA,EACf,kBAAkB;AAAA,EAClB,WAAW;AAAA,EACX,iBAAiB;AAAA,EACjB,iBAAiB;AAAA,EACjB,iBAAiB;AAAA,IACf,WAAW;AAAA,IACX,UAAU;AAAA,IACV,UAAU;AAAA,EACZ;AACF;AAEA,IAAM,2BAA2B,CAAC,aAAa,QAAQ;AACvD,IAAM,kBAAkB,CAAC,iBAAiB,gBAAgB;AAQnD,SAAS,YAAY,KAAsC;AAChE,MAAI,OAAO,QAAQ,YAAY,QAAQ,MAAM;AAC3C,UAAM,IAAI,MAAM,kCAAkC;AAAA,EACpD;AAEA,QAAM,MAAM;AAGZ,MAAI,OAAO,IAAI,kBAAkB,YAAY,IAAI,cAAc,WAAW,GAAG;AAC3E,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AAAA,EACF;AAEA,MACE,OAAO,IAAI,cAAc,YACzB,CAAC,OAAO,UAAU,IAAI,SAAS,KAC/B,IAAI,aAAa,KACjB,IAAI,YAAY,OAChB;AACA,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AAAA,EACF;AAEA,MAAI,OAAO,IAAI,oBAAoB,YAAY,IAAI,gBAAgB,WAAW,GAAG;AAC/E,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AAAA,EACF;AAGA,MAAI;AACJ,MAAI,IAAI,oBAAoB,QAAW;AACrC,QAAI,OAAO,IAAI,oBAAoB,YAAY,IAAI,gBAAgB,WAAW,GAAG;AAC/E,YAAM,IAAI;AAAA,QACR;AAAA,MACF;AAAA,IACF;AACA,sBAAkB,IAAI;AAAA,EACxB;AAEA,QAAM,mBACJ,IAAI,qBAAqB,SACrB,OAAO,IAAI,gBAAgB,IAC3B,eAAe;AAErB,MAAI,kBAAkB,eAAe;AACrC,MAAI,IAAI,oBAAoB,QAAW;AACrC,QAAI,CAAC,yBAAyB,SAAS,IAAI,eAA0D,GAAG;AACtG,YAAM,IAAI;AAAA,QACR,4CAA4C,yBAAyB,KAAK,IAAI,CAAC,UACrE,KAAK,UAAU,IAAI,eAAe,CAAC;AAAA,MAC/C;AAAA,IACF;AACA,sBAAkB,IAAI;AAAA,EACxB;AAGA,MAAI,kBAAkB,EAAE,GAAG,eAAe,gBAAgB;AAC1D,MAAI,IAAI,oBAAoB,QAAW;AACrC,QAAI,OAAO,IAAI,oBAAoB,YAAY,IAAI,oBAAoB,MAAM;AAC3E,YAAM,IAAI,MAAM,4CAA4C;AAAA,IAC9D;AACA,UAAM,KAAK,IAAI;AAEf,QAAI,GAAG,cAAc,QAAW;AAC9B,UAAI,OAAO,GAAG,cAAc,YAAY,CAAC,OAAO,UAAU,GAAG,SAAS,KAAK,GAAG,aAAa,GAAG;AAC5F,cAAM,IAAI;AAAA,UACR;AAAA,QACF;AAAA,MACF;AACA,sBAAgB,YAAY,GAAG;AAAA,IACjC;AAEA,QAAI,GAAG,aAAa,QAAW;AAC7B,UAAI,CAAC,gBAAgB,SAAS,GAAG,QAA0C,GAAG;AAC5E,cAAM,IAAI;AAAA,UACR,qDACK,gBAAgB,KAAK,IAAI,CAAC,UAAU,KAAK,UAAU,GAAG,QAAQ,CAAC;AAAA,QACtE;AAAA,MACF;AACA,sBAAgB,WAAW,GAAG;AAAA,IAChC;AAEA,QAAI,GAAG,aAAa,QAAW;AAC7B,UAAI,OAAO,GAAG,aAAa,YAAY,GAAG,SAAS,WAAW,GAAG;AAC/D,cAAM,IAAI;AAAA,UACR;AAAA,QACF;AAAA,MACF;AACA,sBAAgB,WAAW,GAAG;AAAA,IAChC;AAAA,EACF;AAEA,SAAO;AAAA,IACL,eAAe,IAAI;AAAA,IACnB;AAAA,IACA,WAAW,IAAI;AAAA,IACf,iBAAiB,IAAI;AAAA,IACrB;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;","names":[]}

package/dist/cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli.js

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+// openclaw-engram: Local-first memory plugin
+import {
+  createWeCloneProxy,
+  parseConfig
+} from "./chunk-7V67D4WU.js";
+
+// src/cli.ts
+import { readFileSync, existsSync } from "fs";
+import { resolve } from "path";
+import { homedir } from "os";
+function defaultConfigPath() {
+  const override = process.env.REMNIC_HOME ?? process.env.ENGRAM_HOME;
+  if (override && override.length > 0) {
+    return resolve(override, "connectors", "weclone.json");
+  }
+  const envHome = process.env.HOME;
+  const home = envHome && envHome.length > 0 ? envHome : homedir();
+  return resolve(home, ".remnic", "connectors", "weclone.json");
+}
+var args = process.argv.slice(2);
+var configPath = null;
+for (let i = 0; i < args.length; i++) {
+  if (args[i] === "--config") {
+    if (!args[i + 1]) {
+      console.error("Error: --config requires a path argument");
+      process.exit(1);
+    }
+    configPath = resolve(args[i + 1]);
+    i++;
+  }
+}
+if (configPath === null) {
+  configPath = defaultConfigPath();
+}
+if (!existsSync(configPath)) {
+  console.error(`Config not found: ${configPath}`);
+  console.error("Run: remnic connectors install weclone");
+  process.exit(1);
+}
+var raw;
+try {
+  raw = JSON.parse(readFileSync(configPath, "utf-8"));
+} catch (err) {
+  console.error(`Failed to parse config at ${configPath}: ${err instanceof Error ? err.message : String(err)}`);
+  process.exit(1);
+}
+if (typeof raw !== "object" || raw === null) {
+  console.error(`Config at ${configPath} must be a JSON object`);
+  process.exit(1);
+}
+var config = parseConfig(raw);
+var proxy = createWeCloneProxy(config);
+proxy.start().then(() => {
+  console.log(`WeClone memory proxy listening on :${config.proxyPort}`);
+  console.log(`  WeClone API: ${config.wecloneApiUrl}`);
+  console.log(`  Remnic daemon: ${config.remnicDaemonUrl}`);
+});
+process.on("SIGINT", () => {
+  proxy.stop();
+  process.exit(0);
+});
+process.on("SIGTERM", () => {
+  proxy.stop();
+  process.exit(0);
+});
+//# sourceMappingURL=cli.js.map

package/dist/cli.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/cli.ts"],"sourcesContent":["#!/usr/bin/env node\n/**\n * CLI entrypoint for @remnic/connector-weclone.\n *\n * Reads config from ~/.remnic/connectors/weclone.json (or --config path)\n * and starts the OpenAI-compatible memory proxy. `REMNIC_HOME` (or legacy\n * `ENGRAM_HOME`) can override the default home directory — this matches the\n * override honoured by `remnic connectors install weclone` in @remnic/core.\n */\n\nimport { createWeCloneProxy } from \"./proxy.js\";\nimport { parseConfig } from \"./config.js\";\nimport { readFileSync, existsSync } from \"node:fs\";\nimport { resolve } from \"node:path\";\nimport { homedir } from \"node:os\";\n\n/**\n * Resolve the default proxy config path. Kept in lockstep with\n * @remnic/core's `resolveWeCloneProxyConfigPath()` so install/run pair up\n * without additional wiring from the caller.\n *\n * Both sides use `path.resolve()` (absolute) — NOT `path.join()` — so a\n * relative override like `REMNIC_HOME=tmp/remnic` is normalized against the\n * current working directory. If core and CLI disagreed on this, a relative\n * override could write the config in one location and read it from another,\n * producing spurious \"Config not found\" errors right after a successful\n * install.\n *\n * `HOME=\"\"` edge case: treat an empty-string HOME as absent and fall back\n * to `os.homedir()`. The core helper does the same; if they diverged here,\n * install and run would target different directories when `HOME` is\n * cleared (empty string is not nullish, so `?? os.homedir()` does NOT\n * substitute it).\n */\nfunction defaultConfigPath(): string {\n  const override = process.env.REMNIC_HOME ?? process.env.ENGRAM_HOME;\n  if (override && override.length > 0) {\n    return resolve(override, \"connectors\", \"weclone.json\");\n  }\n  const envHome = process.env.HOME;\n  const home = envHome && envHome.length > 0 ? envHome : homedir();\n  return resolve(home, \".remnic\", \"connectors\", \"weclone.json\");\n}\n\n// Parse --config first so an explicit path takes precedence over env-var\n// resolution. Only fall back to defaultConfigPath() when the user has not\n// supplied an explicit --config flag. This lets `remnic-weclone-proxy\n// --config /abs/path` work even in environments where REMNIC_HOME is\n// misconfigured, without defaultConfigPath() (and any env-var validation\n// it contains) running unnecessarily.\nconst args = process.argv.slice(2);\nlet configPath: string | null = null;\n\nfor (let i = 0; i < args.length; i++) {\n  if (args[i] === \"--config\") {\n    if (!args[i + 1]) {\n      console.error(\"Error: --config requires a path argument\");\n      process.exit(1);\n    }\n    configPath = resolve(args[i + 1]);\n    i++;\n  }\n}\n\nif (configPath === null) {\n  configPath = defaultConfigPath();\n}\n\nif (!existsSync(configPath)) {\n  console.error(`Config not found: ${configPath}`);\n  console.error(\"Run: remnic connectors install weclone\");\n  process.exit(1);\n}\n\nlet raw: unknown;\ntry {\n  raw = JSON.parse(readFileSync(configPath, \"utf-8\"));\n} catch (err) {\n  console.error(`Failed to parse config at ${configPath}: ${err instanceof Error ? err.message : String(err)}`);\n  process.exit(1);\n}\n\nif (typeof raw !== \"object\" || raw === null) {\n  console.error(`Config at ${configPath} must be a JSON object`);\n  process.exit(1);\n}\n\nconst config = parseConfig(raw);\nconst proxy = createWeCloneProxy(config);\n\nproxy.start().then(() => {\n  console.log(`WeClone memory proxy listening on :${config.proxyPort}`);\n  console.log(`  WeClone API: ${config.wecloneApiUrl}`);\n  console.log(`  Remnic daemon: ${config.remnicDaemonUrl}`);\n});\n\nprocess.on(\"SIGINT\", () => {\n  proxy.stop();\n  process.exit(0);\n});\nprocess.on(\"SIGTERM\", () => {\n  proxy.stop();\n  process.exit(0);\n});\n"],"mappings":";;;;;;;;AAYA,SAAS,cAAc,kBAAkB;AACzC,SAAS,eAAe;AACxB,SAAS,eAAe;AAoBxB,SAAS,oBAA4B;AACnC,QAAM,WAAW,QAAQ,IAAI,eAAe,QAAQ,IAAI;AACxD,MAAI,YAAY,SAAS,SAAS,GAAG;AACnC,WAAO,QAAQ,UAAU,cAAc,cAAc;AAAA,EACvD;AACA,QAAM,UAAU,QAAQ,IAAI;AAC5B,QAAM,OAAO,WAAW,QAAQ,SAAS,IAAI,UAAU,QAAQ;AAC/D,SAAO,QAAQ,MAAM,WAAW,cAAc,cAAc;AAC9D;AAQA,IAAM,OAAO,QAAQ,KAAK,MAAM,CAAC;AACjC,IAAI,aAA4B;AAEhC,SAAS,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;AACpC,MAAI,KAAK,CAAC,MAAM,YAAY;AAC1B,QAAI,CAAC,KAAK,IAAI,CAAC,GAAG;AAChB,cAAQ,MAAM,0CAA0C;AACxD,cAAQ,KAAK,CAAC;AAAA,IAChB;AACA,iBAAa,QAAQ,KAAK,IAAI,CAAC,CAAC;AAChC;AAAA,EACF;AACF;AAEA,IAAI,eAAe,MAAM;AACvB,eAAa,kBAAkB;AACjC;AAEA,IAAI,CAAC,WAAW,UAAU,GAAG;AAC3B,UAAQ,MAAM,qBAAqB,UAAU,EAAE;AAC/C,UAAQ,MAAM,wCAAwC;AACtD,UAAQ,KAAK,CAAC;AAChB;AAEA,IAAI;AACJ,IAAI;AACF,QAAM,KAAK,MAAM,aAAa,YAAY,OAAO,CAAC;AACpD,SAAS,KAAK;AACZ,UAAQ,MAAM,6BAA6B,UAAU,KAAK,eAAe,QAAQ,IAAI,UAAU,OAAO,GAAG,CAAC,EAAE;AAC5G,UAAQ,KAAK,CAAC;AAChB;AAEA,IAAI,OAAO,QAAQ,YAAY,QAAQ,MAAM;AAC3C,UAAQ,MAAM,aAAa,UAAU,wBAAwB;AAC7D,UAAQ,KAAK,CAAC;AAChB;AAEA,IAAM,SAAS,YAAY,GAAG;AAC9B,IAAM,QAAQ,mBAAmB,MAAM;AAEvC,MAAM,MAAM,EAAE,KAAK,MAAM;AACvB,UAAQ,IAAI,sCAAsC,OAAO,SAAS,EAAE;AACpE,UAAQ,IAAI,kBAAkB,OAAO,aAAa,EAAE;AACpD,UAAQ,IAAI,oBAAoB,OAAO,eAAe,EAAE;AAC1D,CAAC;AAED,QAAQ,GAAG,UAAU,MAAM;AACzB,QAAM,KAAK;AACX,UAAQ,KAAK,CAAC;AAChB,CAAC;AACD,QAAQ,GAAG,WAAW,MAAM;AAC1B,QAAM,KAAK;AACX,UAAQ,KAAK,CAAC;AAChB,CAAC;","names":[]}

package/dist/index.d.ts

@@ -0,0 +1,126 @@
+/**
+ * WeClone connector configuration.
+ *
+ * Validates user-provided config and applies defaults for optional fields.
+ */
+interface MemoryInjectionConfig {
+    maxTokens: number;
+    position: "system-append" | "system-prepend";
+    template: string;
+}
+interface WeCloneConnectorConfig {
+    wecloneApiUrl: string;
+    wecloneModelName?: string;
+    proxyPort: number;
+    remnicDaemonUrl: string;
+    remnicAuthToken?: string;
+    sessionStrategy: "caller-id" | "single";
+    memoryInjection: MemoryInjectionConfig;
+}
+declare const DEFAULT_CONFIG: WeCloneConnectorConfig;
+/**
+ * Parse and validate a raw config object into a WeCloneConnectorConfig.
+ *
+ * Rejects missing required fields and invalid values with clear messages.
+ * Applies defaults for all optional fields.
+ */
+declare function parseConfig(raw: unknown): WeCloneConnectorConfig;
+
+/**
+ * OpenAI-compatible HTTP proxy for WeClone with Remnic memory injection.
+ *
+ * Intercepts POST /v1/chat/completions to inject recalled memories,
+ * forwards all other requests transparently to the WeClone API.
+ */
+
+interface WeCloneProxy {
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    port: number;
+}
+/**
+ * Create a WeClone proxy instance.
+ */
+declare function createWeCloneProxy(config: WeCloneConnectorConfig): WeCloneProxy;
+
+/**
+ * Memory format adapter.
+ *
+ * Converts Remnic recall results into system prompt sections that
+ * can be injected into OpenAI-compatible chat completion requests.
+ */
+interface RecallResult {
+    content: string;
+    confidence?: number;
+    category?: string;
+}
+/**
+ * Format recall results into a memory block suitable for prompt injection.
+ *
+ * - Sorts memories by confidence (highest first; missing confidence sorts last)
+ * - Truncates combined content to fit within `maxTokens` (approx 4 chars/token)
+ * - Fills in the template's `{memories}` placeholder
+ * - Returns empty string if no memories are provided
+ */
+declare function formatMemoryBlock(memories: RecallResult[], template: string, maxTokens: number): string;
+
+/**
+ * Session mapping strategies.
+ *
+ * Maps caller identity to Remnic session keys so memory is scoped
+ * appropriately per user or shared across all callers.
+ */
+interface ChatCompletionRequest {
+    model?: string;
+    messages?: Array<{
+        role: string;
+        content: string;
+    }>;
+    user?: string;
+    [key: string]: unknown;
+}
+interface SessionMapper {
+    resolve(headers: Record<string, string | string[] | undefined>, body: ChatCompletionRequest): string;
+}
+/**
+ * Returns a fixed session key for single-user setups.
+ */
+declare class SingleSessionMapper implements SessionMapper {
+    private readonly key;
+    constructor(key?: string);
+    resolve(_headers: Record<string, string | string[] | undefined>, _body: ChatCompletionRequest): string;
+}
+/**
+ * Extracts caller identity from request metadata.
+ *
+ * Resolution order:
+ * 1. `X-Caller-Id` header
+ * 2. `user` field in the request body
+ * 3. Falls back to "default"
+ */
+declare class CallerIdSessionMapper implements SessionMapper {
+    private readonly fallback;
+    constructor(fallback?: string);
+    resolve(headers: Record<string, string | string[] | undefined>, body: ChatCompletionRequest): string;
+}
+
+/**
+ * WeClone connector installer.
+ *
+ * Generates setup instructions for connecting a WeClone avatar
+ * to Remnic memory through the OpenAI-compatible proxy.
+ */
+
+interface WeCloneInstallResult {
+    config: WeCloneConnectorConfig;
+    instructions: string;
+}
+/**
+ * Generate human-readable setup instructions for the WeClone connector.
+ *
+ * Tells the user how to start each component and reconfigure their
+ * bot to route through the memory-aware proxy.
+ */
+declare function generateWeCloneInstructions(config: WeCloneConnectorConfig): WeCloneInstallResult;
+
+export { CallerIdSessionMapper, type ChatCompletionRequest, DEFAULT_CONFIG, type MemoryInjectionConfig, type RecallResult, type SessionMapper, SingleSessionMapper, type WeCloneConnectorConfig, type WeCloneInstallResult, type WeCloneProxy, createWeCloneProxy, formatMemoryBlock, generateWeCloneInstructions, parseConfig };

package/dist/index.js

@@ -0,0 +1,63 @@
+// openclaw-engram: Local-first memory plugin
+import {
+  CallerIdSessionMapper,
+  DEFAULT_CONFIG,
+  SingleSessionMapper,
+  createWeCloneProxy,
+  formatMemoryBlock,
+  parseConfig
+} from "./chunk-7V67D4WU.js";
+
+// src/installer.ts
+function generateWeCloneInstructions(config) {
+  const instructions = `
+WeClone + Remnic Memory Connector Setup
+========================================
+
+Prerequisites:
+  - WeClone avatar API server
+  - Remnic daemon (remnic-server)
+  - Node.js 18+
+
+Steps:
+
+1. Start the WeClone API server
+   Ensure it is listening at: ${config.wecloneApiUrl}
+
+2. Start the Remnic daemon
+   Ensure it is listening at: ${config.remnicDaemonUrl}
+
+3. Start the connector proxy
+   remnic-weclone-proxy --config ~/.remnic/connectors/weclone.json
+
+   The proxy will listen on port ${config.proxyPort} and forward
+   requests to WeClone after injecting Remnic memory context.
+   (All settings are read from the config file.)
+
+4. Update your bot / client configuration
+   Change the API base URL from:
+     ${config.wecloneApiUrl}
+   to:
+     http://localhost:${config.proxyPort}/v1
+
+   All OpenAI-compatible requests will be transparently proxied
+   with memory injection for chat completions.
+
+Session strategy: ${config.sessionStrategy}
+${config.sessionStrategy === "caller-id" ? '  Set X-Caller-Id header or "user" field to scope memory per caller.' : "  All requests share a single memory session."}
+
+Health check:
+  GET http://localhost:${config.proxyPort}/health
+`.trim();
+  return { config, instructions };
+}
+export {
+  CallerIdSessionMapper,
+  DEFAULT_CONFIG,
+  SingleSessionMapper,
+  createWeCloneProxy,
+  formatMemoryBlock,
+  generateWeCloneInstructions,
+  parseConfig
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/installer.ts"],"sourcesContent":["/**\n * WeClone connector installer.\n *\n * Generates setup instructions for connecting a WeClone avatar\n * to Remnic memory through the OpenAI-compatible proxy.\n */\n\nimport type { WeCloneConnectorConfig } from \"./config.js\";\n\nexport interface WeCloneInstallResult {\n  config: WeCloneConnectorConfig;\n  instructions: string;\n}\n\n/**\n * Generate human-readable setup instructions for the WeClone connector.\n *\n * Tells the user how to start each component and reconfigure their\n * bot to route through the memory-aware proxy.\n */\nexport function generateWeCloneInstructions(\n  config: WeCloneConnectorConfig\n): WeCloneInstallResult {\n  const instructions = `\nWeClone + Remnic Memory Connector Setup\n========================================\n\nPrerequisites:\n  - WeClone avatar API server\n  - Remnic daemon (remnic-server)\n  - Node.js 18+\n\nSteps:\n\n1. Start the WeClone API server\n   Ensure it is listening at: ${config.wecloneApiUrl}\n\n2. Start the Remnic daemon\n   Ensure it is listening at: ${config.remnicDaemonUrl}\n\n3. Start the connector proxy\n   remnic-weclone-proxy --config ~/.remnic/connectors/weclone.json\n\n   The proxy will listen on port ${config.proxyPort} and forward\n   requests to WeClone after injecting Remnic memory context.\n   (All settings are read from the config file.)\n\n4. Update your bot / client configuration\n   Change the API base URL from:\n     ${config.wecloneApiUrl}\n   to:\n     http://localhost:${config.proxyPort}/v1\n\n   All OpenAI-compatible requests will be transparently proxied\n   with memory injection for chat completions.\n\nSession strategy: ${config.sessionStrategy}\n${config.sessionStrategy === \"caller-id\" ? '  Set X-Caller-Id header or \"user\" field to scope memory per caller.' : \"  All requests share a single memory session.\"}\n\nHealth check:\n  GET http://localhost:${config.proxyPort}/health\n`.trim();\n\n  return { config, instructions };\n}\n"],"mappings":";;;;;;;;;;;AAoBO,SAAS,4BACd,QACsB;AACtB,QAAM,eAAe;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gCAYS,OAAO,aAAa;AAAA;AAAA;AAAA,gCAGpB,OAAO,eAAe;AAAA;AAAA;AAAA;AAAA;AAAA,mCAKnB,OAAO,SAAS;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,OAM5C,OAAO,aAAa;AAAA;AAAA,wBAEH,OAAO,SAAS;AAAA;AAAA;AAAA;AAAA;AAAA,oBAKpB,OAAO,eAAe;AAAA,EACxC,OAAO,oBAAoB,cAAc,yEAAyE,+CAA+C;AAAA;AAAA;AAAA,yBAG1I,OAAO,SAAS;AAAA,EACvC,KAAK;AAEL,SAAO,EAAE,QAAQ,aAAa;AAChC;","names":[]}

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@remnic/connector-weclone",
+  "version": "1.0.1",
+  "description": "OpenAI-compatible proxy adding Remnic persistent memory to WeClone avatars",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "bin": {
+    "remnic-weclone-proxy": "dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5.7.0",
+    "tsx": "^4.0.0"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/joshuaswarren/remnic.git",
+    "directory": "packages/connector-weclone"
+  },
+  "keywords": [
+    "remnic",
+    "memory",
+    "weclone",
+    "proxy",
+    "ai-agent"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts src/cli.ts --format esm --dts",
+    "test": "tsx --test src/*.test.ts"
+  }
+}