teleton 0.8.1 → 0.8.3

package/dist/{chunk-3S4GGLLR.js → chunk-35MX4ZUI.js}

@@ -7,16 +7,16 @@ import {
   EMBEDDING_CACHE_MAX_ENTRIES,
   EMBEDDING_CACHE_TTL_DAYS,
   VOYAGE_BATCH_SIZE
-} from "./chunk-UP55PXFH.js";
+} from "./chunk-C4NKJT2Z.js";
 import {
   fetchWithTimeout
 } from "./chunk-XQUHC3JZ.js";
 import {
-  TELETON_ROOT
-} from "./chunk-EYWNOHMJ.js";
+  LocalEmbeddingProvider
+} from "./chunk-CUE4UZXR.js";
 import {
   createLogger
-} from "./chunk-RCMD3U65.js";
+} from "./chunk-NQ6FZKCE.js";
 
 // src/memory/embeddings/provider.ts
 var NoopEmbeddingProvider = class {
@@ -52,7 +52,7 @@ var AnthropicEmbeddingProvider = class {
     this.dimensions = dims[this.model] ?? 512;
   }
   async embedQuery(text) {
-    const result = await this.embed([text]);
+    const result = await this.embed([text], "query");
     return result[0] ?? [];
   }
   async embedBatch(texts) {
@@ -66,7 +66,7 @@ var AnthropicEmbeddingProvider = class {
     }
     return results;
   }
-  async embed(texts) {
+  async embed(texts, inputType = "document") {
     const response = await fetchWithTimeout(`${this.baseUrl}/embeddings`, {
       method: "POST",
       headers: {
@@ -76,7 +76,7 @@ var AnthropicEmbeddingProvider = class {
       body: JSON.stringify({
         input: texts,
         model: this.model,
-        input_type: "document"
+        input_type: inputType
       })
     });
     if (!response.ok) {
@@ -88,92 +88,6 @@ var AnthropicEmbeddingProvider = class {
   }
 };
 
-// src/memory/embeddings/local.ts
-import { pipeline, env } from "@huggingface/transformers";
-import { join } from "path";
-import { mkdirSync } from "fs";
-var log = createLogger("Memory");
-var modelCacheDir = join(TELETON_ROOT, "models");
-try {
-  mkdirSync(modelCacheDir, { recursive: true });
-} catch {
-}
-env.cacheDir = modelCacheDir;
-var extractorPromise = null;
-function getExtractor(model) {
-  if (!extractorPromise) {
-    log.info(`Loading local embedding model: ${model} (cache: ${modelCacheDir})`);
-    extractorPromise = pipeline("feature-extraction", model, {
-      dtype: "fp32",
-      // Explicit cache_dir to avoid any env race condition
-      cache_dir: modelCacheDir
-    }).then((ext) => {
-      log.info(`Local embedding model ready`);
-      return ext;
-    }).catch((err) => {
-      log.error(`Failed to load embedding model: ${err.message}`);
-      extractorPromise = null;
-      throw err;
-    });
-  }
-  return extractorPromise;
-}
-var LocalEmbeddingProvider = class {
-  id = "local";
-  model;
-  dimensions;
-  _disabled = false;
-  constructor(config) {
-    this.model = config.model || "Xenova/all-MiniLM-L6-v2";
-    this.dimensions = 384;
-  }
-  /**
-   * Pre-download and load the model at startup.
-   * If loading fails, retries once then marks provider as disabled (FTS5-only).
-   * Call this once during app init — avoids retry spam on every message.
-   * @returns true if model loaded successfully, false if fallback to noop
-   */
-  async warmup() {
-    for (let attempt = 1; attempt <= 2; attempt++) {
-      try {
-        await getExtractor(this.model);
-        return true;
-      } catch {
-        if (attempt === 1) {
-          log.warn(`Embedding model load failed (attempt 1), retrying...`);
-          await new Promise((r) => setTimeout(r, 1e3));
-        } else {
-          log.warn(
-            `Local embedding model unavailable \u2014 falling back to FTS5-only search (no vector embeddings)`
-          );
-          this._disabled = true;
-          return false;
-        }
-      }
-    }
-    return false;
-  }
-  async embedQuery(text) {
-    if (this._disabled) return [];
-    const extractor = await getExtractor(this.model);
-    const output = await extractor(text, { pooling: "mean", normalize: true });
-    return Array.from(output.data);
-  }
-  async embedBatch(texts) {
-    if (this._disabled) return [];
-    if (texts.length === 0) return [];
-    const extractor = await getExtractor(this.model);
-    const output = await extractor(texts, { pooling: "mean", normalize: true });
-    const data = output.data;
-    const dims = this.dimensions;
-    const results = [];
-    for (let i = 0; i < texts.length; i++) {
-      results.push(Array.from(data.slice(i * dims, (i + 1) * dims)));
-    }
-    return results;
-  }
-};
-
 // src/memory/embeddings/utils.ts
 import { createHash } from "crypto";
 function hashText(text) {
@@ -202,6 +116,16 @@ var CachedEmbeddingProvider = class _CachedEmbeddingProvider {
     this.id = inner.id;
     this.model = inner.model;
     this.dimensions = inner.dimensions;
+    this.stmtCacheGet = db.prepare(
+      `SELECT embedding FROM embedding_cache WHERE hash = ? AND model = ? AND provider = ?`
+    );
+    this.stmtCachePut = db.prepare(
+      `INSERT OR REPLACE INTO embedding_cache (hash, embedding, model, provider, dims, created_at, accessed_at)
+       VALUES (?, ?, ?, ?, ?, unixepoch(), unixepoch())`
+    );
+    this.stmtCacheTouch = db.prepare(
+      `UPDATE embedding_cache SET accessed_at = unixepoch() WHERE hash = ? AND model = ? AND provider = ?`
+    );
   }
   id;
   model;
@@ -210,21 +134,17 @@ var CachedEmbeddingProvider = class _CachedEmbeddingProvider {
   hits = 0;
   misses = 0;
   ops = 0;
+  stmtCacheGet;
+  stmtCachePut;
+  stmtCacheTouch;
   cacheGet(hash) {
-    return this.db.prepare(
-      `SELECT embedding FROM embedding_cache WHERE hash = ? AND model = ? AND provider = ?`
-    ).get(hash, this.model, this.id);
+    return this.stmtCacheGet.get(hash, this.model, this.id);
   }
   cachePut(hash, blob) {
-    this.db.prepare(
-      `INSERT OR REPLACE INTO embedding_cache (hash, embedding, model, provider, dims, created_at, accessed_at)
-         VALUES (?, ?, ?, ?, ?, unixepoch(), unixepoch())`
-    ).run(hash, blob, this.model, this.id, this.dimensions);
+    this.stmtCachePut.run(hash, blob, this.model, this.id, this.dimensions);
   }
   cacheTouch(hash) {
-    this.db.prepare(
-      `UPDATE embedding_cache SET accessed_at = unixepoch() WHERE hash = ? AND model = ? AND provider = ?`
-    ).run(hash, this.model, this.id);
+    this.stmtCacheTouch.run(hash, this.model, this.id);
   }
   async warmup() {
     return this.inner.warmup?.() ?? true;
@@ -340,7 +260,6 @@ function createEmbeddingProvider(config) {
 export {
   NoopEmbeddingProvider,
   AnthropicEmbeddingProvider,
-  LocalEmbeddingProvider,
   hashText,
   serializeEmbedding,
   deserializeEmbedding,

package/dist/chunk-3UFPFWYP.js

@@ -0,0 +1,12 @@
+// src/utils/errors.ts
+function getErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function isHttpError(err) {
+  return typeof err === "object" && err !== null && ("status" in err || "response" in err);
+}
+
+export {
+  getErrorMessage,
+  isHttpError
+};

package/dist/chunk-5SEMA47R.js

@@ -0,0 +1,75 @@
+import {
+  createLogger
+} from "./chunk-NQ6FZKCE.js";
+
+// src/api/tls.ts
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+import { createHash, X509Certificate } from "crypto";
+import { generate } from "selfsigned";
+var log = createLogger("TLS");
+function computeFingerprint(certPem) {
+  const x509 = new X509Certificate(certPem);
+  const der = x509.raw;
+  return createHash("sha256").update(der).digest("hex");
+}
+function isCertValid(certPem) {
+  try {
+    const x509 = new X509Certificate(certPem);
+    const now = /* @__PURE__ */ new Date();
+    return now >= new Date(x509.validFrom) && now <= new Date(x509.validTo);
+  } catch {
+    return false;
+  }
+}
+async function ensureTlsCert(dataDir) {
+  const certPath = join(dataDir, "api-cert.pem");
+  const keyPath = join(dataDir, "api-key.pem");
+  if (existsSync(certPath) && existsSync(keyPath)) {
+    const cert = readFileSync(certPath, "utf-8");
+    const key = readFileSync(keyPath, "utf-8");
+    if (isCertValid(cert)) {
+      const fingerprint2 = computeFingerprint(cert);
+      log.info("Loaded existing TLS certificate");
+      return { cert, key, fingerprint: fingerprint2 };
+    }
+    log.warn("Existing TLS certificate is expired, regenerating");
+  }
+  log.info("Generating self-signed TLS certificate");
+  const notBeforeDate = /* @__PURE__ */ new Date();
+  const notAfterDate = /* @__PURE__ */ new Date();
+  notAfterDate.setFullYear(notAfterDate.getFullYear() + 2);
+  const pems = await generate([{ name: "commonName", value: "teleton-api" }], {
+    keySize: 2048,
+    algorithm: "sha256",
+    notBeforeDate,
+    notAfterDate,
+    extensions: [
+      { name: "basicConstraints", cA: false, critical: true },
+      {
+        name: "keyUsage",
+        digitalSignature: true,
+        keyEncipherment: true,
+        critical: true
+      },
+      { name: "extKeyUsage", serverAuth: true },
+      {
+        name: "subjectAltName",
+        altNames: [
+          { type: 2, value: "localhost" },
+          { type: 7, ip: "127.0.0.1" },
+          { type: 7, ip: "::1" }
+        ]
+      }
+    ]
+  });
+  writeFileSync(certPath, pems.cert, { mode: 384 });
+  writeFileSync(keyPath, pems.private, { mode: 384 });
+  const fingerprint = computeFingerprint(pems.cert);
+  log.info(`TLS certificate generated (fingerprint: ${fingerprint.slice(0, 16)}...)`);
+  return { cert: pems.cert, key: pems.private, fingerprint };
+}
+
+export {
+  ensureTlsCert
+};

package/dist/{chunk-PHSAHTK4.js → chunk-6OOHHJ4N.js}

@@ -1,7 +1,3 @@
-import {
-  createLogger
-} from "./chunk-RCMD3U65.js";
-
 // src/config/providers.ts
 var PROVIDER_REGISTRY = {
   anthropic: {
@@ -30,12 +26,12 @@ var PROVIDER_REGISTRY = {
   },
   openai: {
     id: "openai",
-    displayName: "OpenAI (GPT-4o)",
+    displayName: "OpenAI (GPT-5.4)",
     envVar: "OPENAI_API_KEY",
     keyPrefix: "sk-",
     keyHint: "sk-proj-...",
     consoleUrl: "https://platform.openai.com/api-keys",
-    defaultModel: "gpt-4o",
+    defaultModel: "gpt-5.4",
     utilityModel: "gpt-4o-mini",
     toolLimit: 128,
     piAiProvider: "openai"
@@ -206,109 +202,8 @@ function validateApiKeyFormat(provider, key) {
   return void 0;
 }
 
-// src/providers/claude-code-credentials.ts
-import { readFileSync, existsSync } from "fs";
-import { execSync } from "child_process";
-import { homedir } from "os";
-import { join } from "path";
-var log = createLogger("ClaudeCodeCreds");
-var cachedToken = null;
-var cachedExpiresAt = 0;
-function getClaudeConfigDir() {
-  return process.env.CLAUDE_CONFIG_DIR || join(homedir(), ".claude");
-}
-function getCredentialsFilePath() {
-  return join(getClaudeConfigDir(), ".credentials.json");
-}
-function readCredentialsFile() {
-  const filePath = getCredentialsFilePath();
-  if (!existsSync(filePath)) return null;
-  try {
-    const raw = readFileSync(filePath, "utf-8");
-    return JSON.parse(raw);
-  } catch (e) {
-    log.warn({ err: e, path: filePath }, "Failed to parse Claude Code credentials file");
-    return null;
-  }
-}
-function readKeychainCredentials() {
-  const serviceNames = ["Claude Code-credentials", "Claude Code"];
-  for (const service of serviceNames) {
-    try {
-      const raw = execSync(`security find-generic-password -s "${service}" -w`, {
-        encoding: "utf-8",
-        stdio: ["pipe", "pipe", "pipe"]
-      }).trim();
-      return JSON.parse(raw);
-    } catch {
-    }
-  }
-  return null;
-}
-function readCredentials() {
-  if (process.platform === "darwin") {
-    const keychainCreds = readKeychainCredentials();
-    if (keychainCreds) return keychainCreds;
-    log.debug("Keychain read failed, falling back to credentials file");
-  }
-  return readCredentialsFile();
-}
-function extractToken(creds) {
-  const oauth = creds.claudeAiOauth;
-  if (!oauth?.accessToken) {
-    log.warn("Claude Code credentials found but missing accessToken");
-    return null;
-  }
-  return {
-    token: oauth.accessToken,
-    expiresAt: oauth.expiresAt ?? 0
-  };
-}
-function getClaudeCodeApiKey(fallbackKey) {
-  if (cachedToken && Date.now() < cachedExpiresAt) {
-    return cachedToken;
-  }
-  const creds = readCredentials();
-  if (creds) {
-    const extracted = extractToken(creds);
-    if (extracted) {
-      cachedToken = extracted.token;
-      cachedExpiresAt = extracted.expiresAt;
-      log.debug("Claude Code credentials loaded successfully");
-      return cachedToken;
-    }
-  }
-  if (fallbackKey && fallbackKey.length > 0) {
-    log.warn("Claude Code credentials not found, using fallback api_key from config");
-    return fallbackKey;
-  }
-  throw new Error("No Claude Code credentials found. Run 'claude login' or set api_key in config.");
-}
-function refreshClaudeCodeApiKey() {
-  cachedToken = null;
-  cachedExpiresAt = 0;
-  const creds = readCredentials();
-  if (creds) {
-    const extracted = extractToken(creds);
-    if (extracted) {
-      cachedToken = extracted.token;
-      cachedExpiresAt = extracted.expiresAt;
-      log.info("Claude Code credentials refreshed from disk");
-      return cachedToken;
-    }
-  }
-  log.warn("Failed to refresh Claude Code credentials from disk");
-  return null;
-}
-function isClaudeCodeTokenValid() {
-  return cachedToken !== null && Date.now() < cachedExpiresAt;
-}
-
 export {
   getProviderMetadata,
   getSupportedProviders,
-  validateApiKeyFormat,
-  getClaudeCodeApiKey,
-  refreshClaudeCodeApiKey,
-  isClaudeCodeTokenValid
+  validateApiKeyFormat
 };