@askexenow/exe-os 0.9.227 → 0.9.229

package/dist/chunk-SUNYJ6YE.js

@@ -0,0 +1,204 @@
+import {
+  redactSecrets
+} from "./chunk-F7LU65PQ.js";
+import {
+  isExeMcpTool,
+  stripExeMcpPrefix
+} from "./chunk-HYZV25LY.js";
+
+// src/lib/content-extractor.ts
+import { readFileSync } from "fs";
+var MAX_CONTENT = 2e3;
+var MAX_OUTPUT = 1e3;
+function extractSemanticText(toolName, toolInput, toolResponse) {
+  let extracted;
+  switch (toolName) {
+    case "Write":
+      extracted = extractWrite(toolInput);
+      break;
+    case "Edit":
+      extracted = extractEdit(toolInput);
+      break;
+    case "Read":
+      extracted = extractRead(toolInput, toolResponse);
+      break;
+    case "Bash":
+      extracted = extractBash(toolInput, toolResponse);
+      break;
+    case "Grep":
+      extracted = extractGrep(toolInput, toolResponse);
+      break;
+    case "Glob":
+      extracted = extractGlob(toolInput, toolResponse);
+      break;
+    default:
+      if (isExeMcpTool(toolName)) {
+        extracted = extractExeMemMcp(toolName, toolInput, toolResponse);
+      } else if (toolName.startsWith("mcp__")) {
+        extracted = extractGenericMcp(toolName, toolInput, toolResponse);
+      } else {
+        extracted = extractDefault(toolName, toolInput, toolResponse);
+      }
+  }
+  return redactSecrets(extracted).text;
+}
+function findContainingChunk(filePath, snippet) {
+  try {
+    const ext = filePath.split(".").pop()?.toLowerCase();
+    if (ext !== "ts" && ext !== "tsx" && ext !== "js" && ext !== "jsx") return "";
+    const source = readFileSync(filePath, "utf8");
+    const lines = source.split("\n");
+    const lowerSnippet = snippet.toLowerCase().slice(0, 80);
+    let matchLine = -1;
+    for (let i = 0; i < lines.length; i++) {
+      if (lines[i].toLowerCase().includes(lowerSnippet)) {
+        matchLine = i;
+        break;
+      }
+    }
+    if (matchLine === -1) return "";
+    for (let i = matchLine; i >= 0; i--) {
+      const line = lines[i];
+      const fnMatch = line.match(/(?:export\s+)?(?:async\s+)?function\s+(\w+)/);
+      if (fnMatch) return `Function ${fnMatch[1]} in ${filePath}:${i + 1}`;
+      const classMatch = line.match(/(?:export\s+)?class\s+(\w+)/);
+      if (classMatch) return `Class ${classMatch[1]} in ${filePath}:${i + 1}`;
+      const arrowMatch = line.match(/(?:export\s+)?(?:const|let)\s+(\w+)\s*=\s*(?:async\s+)?\(/);
+      if (arrowMatch) return `Function ${arrowMatch[1]} in ${filePath}:${i + 1}`;
+    }
+  } catch {
+  }
+  return "";
+}
+function extractWrite(input) {
+  const filePath = String(input.file_path ?? "");
+  const content = String(input.content ?? "");
+  const chunkContext = findContainingChunk(filePath, content.slice(0, 200));
+  const prefix = chunkContext ? `Wrote ${filePath} (${chunkContext})` : `Wrote ${filePath}`;
+  return `${prefix}
+${content.slice(0, MAX_CONTENT)}`;
+}
+function extractEdit(input) {
+  const filePath = String(input.file_path ?? "");
+  const oldStr = String(input.old_string ?? "");
+  const newStr = String(input.new_string ?? "");
+  const chunkContext = findContainingChunk(filePath, oldStr.slice(0, 200));
+  const prefix = chunkContext ? `Edited ${filePath} (${chunkContext})` : `Edited ${filePath}`;
+  return `${prefix}
+Removed: ${oldStr.slice(0, MAX_CONTENT / 2)}
+Added: ${newStr.slice(0, MAX_CONTENT / 2)}`;
+}
+function extractRead(input, response) {
+  const filePath = String(input.file_path ?? "");
+  const file = response.file;
+  const content = file ? String(file.content ?? "") : "";
+  if (!content) {
+    const text = String(response.text ?? response.content ?? "");
+    return `Read ${filePath}
+${text.slice(0, MAX_CONTENT)}`;
+  }
+  return `Read ${filePath}
+${content.slice(0, MAX_CONTENT)}`;
+}
+function extractBash(input, response) {
+  const command = String(input.command ?? "");
+  const description = input.description ? String(input.description) : "";
+  const stdout = String(response.stdout ?? response.text ?? "");
+  const stderr = String(response.stderr ?? "");
+  const parts = [description ? `${description}: ${command}` : `Ran: ${command}`];
+  if (stdout) parts.push(`Output: ${stdout.slice(0, MAX_OUTPUT)}`);
+  if (stderr && !stdout) parts.push(`Error: ${stderr.slice(0, MAX_OUTPUT)}`);
+  return parts.join("\n");
+}
+function extractGrep(input, response) {
+  const pattern = String(input.pattern ?? "");
+  const path = input.path ? String(input.path) : "";
+  const output = String(response.text ?? response.content ?? JSON.stringify(response).slice(0, MAX_OUTPUT));
+  return `Searched for "${pattern}"${path ? ` in ${path}` : ""}
+${output.slice(0, MAX_OUTPUT)}`;
+}
+function extractGlob(input, response) {
+  const pattern = String(input.pattern ?? "");
+  const output = String(response.text ?? response.content ?? JSON.stringify(response).slice(0, MAX_OUTPUT));
+  return `Found files matching "${pattern}"
+${output.slice(0, MAX_OUTPUT)}`;
+}
+function extractExeMemMcp(toolName, input, response) {
+  const shortName = stripExeMcpPrefix(toolName);
+  switch (shortName) {
+    case "store_memory": {
+      const text = String(input.text ?? input.query ?? "");
+      return `Stored memory: ${text.slice(0, MAX_CONTENT)}`;
+    }
+    case "recall_my_memory":
+    case "ask_team_memory": {
+      const query = String(input.query ?? "");
+      const member = input.team_member ? ` (from ${input.team_member})` : "";
+      const resultText = extractResponseText(response);
+      return `Memory search${member}: "${query}"
+${resultText.slice(0, MAX_OUTPUT)}`;
+    }
+    case "create_task": {
+      const title = String(input.title ?? "");
+      const assignedTo = String(input.assigned_to ?? "");
+      const priority = String(input.priority ?? "p1");
+      const context = String(input.context ?? "");
+      return `Task created: "${title}" assigned to ${assignedTo} [${priority}]
+${context.slice(0, MAX_CONTENT)}`;
+    }
+    case "update_task": {
+      const taskId = String(input.task_id ?? "");
+      const status = String(input.status ?? "");
+      const result = input.result ? String(input.result) : "";
+      return `Task updated: ${taskId} \u2192 ${status}${result ? `
+Result: ${result.slice(0, MAX_CONTENT)}` : ""}`;
+    }
+    case "list_tasks": {
+      const resultText = extractResponseText(response);
+      return `Listed tasks
+${resultText.slice(0, MAX_OUTPUT)}`;
+    }
+    default: {
+      return extractGenericMcp(toolName, input, response);
+    }
+  }
+}
+function extractGenericMcp(toolName, input, response) {
+  const shortName = toolName.replace(/^mcp__[^_]+__/, "");
+  const inputParts = Object.entries(input).filter(([, v]) => v != null && String(v).length > 0).map(([k, v]) => `${k}: ${String(v).slice(0, 200)}`).join(", ");
+  const resultText = extractResponseText(response);
+  return `${shortName}(${inputParts})
+${resultText.slice(0, MAX_OUTPUT)}`;
+}
+function extractDefault(toolName, input, response) {
+  const inputStr = JSON.stringify(input);
+  const resultText = extractResponseText(response);
+  return `Tool: ${toolName}
+${inputStr.slice(0, MAX_CONTENT / 2)}
+${resultText.slice(0, MAX_OUTPUT)}`;
+}
+function extractResponseText(response) {
+  if (typeof response.text === "string") return response.text;
+  if (typeof response.content === "string") return response.content;
+  if (Array.isArray(response.content)) {
+    return response.content.map((block) => {
+      if (typeof block === "object" && block !== null && "text" in block) {
+        return String(block.text);
+      }
+      return "";
+    }).filter(Boolean).join("\n");
+  }
+  if (Array.isArray(response)) {
+    return response.map((item) => {
+      if (typeof item === "object" && item !== null && "text" in item) {
+        return String(item.text);
+      }
+      return "";
+    }).filter(Boolean).join("\n");
+  }
+  return JSON.stringify(response).slice(0, MAX_OUTPUT);
+}
+
+export {
+  extractSemanticText
+};

package/dist/chunk-SVXDCELZ.js

@@ -0,0 +1,163 @@
+// src/lib/registry-proxy.ts
+import { createServer } from "http";
+import { Readable } from "stream";
+function parsePullTokens(raw) {
+  return (raw ?? "").split(/[\n,]/).map((s) => s.trim()).filter(Boolean);
+}
+function registryProxyOptionsFromEnv(env = process.env) {
+  const upstreamToken = env.EXE_REGISTRY_PROXY_UPSTREAM_TOKEN || env.GHCR_TOKEN || "";
+  const pullTokens = parsePullTokens(env.EXE_REGISTRY_PROXY_PULL_TOKENS);
+  return {
+    port: Number(env.EXE_REGISTRY_PROXY_PORT || 3201),
+    host: env.EXE_REGISTRY_PROXY_HOST || "0.0.0.0",
+    upstream: env.EXE_REGISTRY_PROXY_UPSTREAM || "https://ghcr.io",
+    upstreamUsername: env.EXE_REGISTRY_PROXY_UPSTREAM_USERNAME || env.GHCR_USERNAME || "askexe",
+    upstreamToken,
+    pullTokens,
+    allowedNamespace: env.EXE_REGISTRY_PROXY_ALLOWED_NAMESPACE || "askexe"
+  };
+}
+function assertRegistryProxyConfig(options) {
+  if (!options.upstreamToken) throw new Error("EXE_REGISTRY_PROXY_UPSTREAM_TOKEN or GHCR_TOKEN is required");
+  if (options.pullTokens.length === 0) throw new Error("EXE_REGISTRY_PROXY_PULL_TOKENS is required");
+  if (!options.allowedNamespace || !/^[a-z0-9._-]+$/i.test(options.allowedNamespace)) {
+    throw new Error("EXE_REGISTRY_PROXY_ALLOWED_NAMESPACE must be a registry-safe namespace");
+  }
+}
+function timingSafeIncludes(values, candidate) {
+  return values.some((value) => value === candidate);
+}
+function parseBasicAuth(header) {
+  if (!header?.startsWith("Basic ")) return null;
+  try {
+    const decoded = Buffer.from(header.slice("Basic ".length), "base64").toString("utf8");
+    const idx = decoded.indexOf(":");
+    if (idx < 0) return null;
+    return { username: decoded.slice(0, idx), password: decoded.slice(idx + 1) };
+  } catch {
+    return null;
+  }
+}
+function unauthorized(res) {
+  res.writeHead(401, {
+    "www-authenticate": 'Basic realm="AskExe Registry Proxy"',
+    "content-type": "application/json"
+  });
+  res.end(JSON.stringify({ error: "registry proxy authentication required" }));
+}
+function isAllowedPath(pathname, namespace) {
+  if (pathname === "/health") return true;
+  if (pathname === "/v2/" || pathname === "/v2") return true;
+  const prefix = `/v2/${namespace}/`;
+  if (!pathname.startsWith(prefix)) return false;
+  if (pathname.includes("..") || /%2f/i.test(pathname)) return false;
+  return true;
+}
+function parseBearerChallenge(header) {
+  if (!header?.toLowerCase().startsWith("bearer ")) return null;
+  const raw = header.slice("Bearer ".length);
+  const params = new URLSearchParams();
+  for (const part of raw.match(/(?:[^,"]+|"[^"]*")+/g) ?? []) {
+    const idx = part.indexOf("=");
+    if (idx < 0) continue;
+    const key = part.slice(0, idx).trim();
+    const value = part.slice(idx + 1).trim().replace(/^"|"$/g, "");
+    params.set(key, value);
+  }
+  const realm = params.get("realm");
+  if (!realm) return null;
+  params.delete("realm");
+  return { realm, params };
+}
+async function fetchUpstreamWithRegistryAuth(url, init, upstreamBasicAuth) {
+  const firstHeaders = new Headers(init.headers);
+  firstHeaders.set("authorization", `Basic ${upstreamBasicAuth}`);
+  const first = await fetch(url, { ...init, headers: firstHeaders });
+  if (first.status !== 401) return first;
+  const challenge = parseBearerChallenge(first.headers.get("www-authenticate"));
+  if (!challenge) return first;
+  const tokenUrl = new URL(challenge.realm);
+  for (const [key, value] of challenge.params.entries()) tokenUrl.searchParams.set(key, value);
+  const tokenRes = await fetch(tokenUrl, { headers: { authorization: `Basic ${upstreamBasicAuth}` } });
+  if (!tokenRes.ok) return first;
+  const tokenJson = await tokenRes.json();
+  const token = tokenJson.token ?? tokenJson.access_token;
+  if (!token) return first;
+  const retryHeaders = new Headers(init.headers);
+  retryHeaders.set("authorization", `Bearer ${token}`);
+  return fetch(url, { ...init, headers: retryHeaders });
+}
+function copyResponseHeaders(from, to) {
+  for (const [key, value] of from.entries()) {
+    const lower = key.toLowerCase();
+    if (["connection", "keep-alive", "transfer-encoding", "content-encoding"].includes(lower)) continue;
+    to.setHeader(key, value);
+  }
+}
+function createRegistryProxyServer(options) {
+  assertRegistryProxyConfig(options);
+  const upstream = new URL(options.upstream ?? "https://ghcr.io");
+  const namespace = options.allowedNamespace ?? "askexe";
+  const upstreamAuth = Buffer.from(`${options.upstreamUsername ?? "askexe"}:${options.upstreamToken}`).toString("base64");
+  return createServer(async (req, res) => {
+    const requestUrl = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
+    if (requestUrl.pathname === "/health") {
+      res.writeHead(200, { "content-type": "application/json" });
+      res.end(JSON.stringify({ ok: true, service: "exe-registry-proxy", upstream: upstream.origin, namespace }));
+      return;
+    }
+    if (!isAllowedPath(requestUrl.pathname, namespace)) {
+      res.writeHead(404, { "content-type": "application/json" });
+      res.end(JSON.stringify({ error: "registry path not allowed" }));
+      return;
+    }
+    const auth = parseBasicAuth(req.headers.authorization);
+    if (!auth || !timingSafeIncludes(options.pullTokens, auth.password)) {
+      unauthorized(res);
+      return;
+    }
+    const upstreamUrl = new URL(requestUrl.pathname + requestUrl.search, upstream.origin);
+    const headers = new Headers();
+    for (const [key, value] of Object.entries(req.headers)) {
+      if (!value) continue;
+      const lower = key.toLowerCase();
+      if (["host", "connection", "authorization", "content-length"].includes(lower)) continue;
+      headers.set(key, Array.isArray(value) ? value.join(",") : value);
+    }
+    headers.set("authorization", `Basic ${upstreamAuth}`);
+    try {
+      const upstreamRes = await fetchUpstreamWithRegistryAuth(upstreamUrl, {
+        method: req.method,
+        headers,
+        body: req.method === "GET" || req.method === "HEAD" ? void 0 : req,
+        // Required by undici when streaming request bodies.
+        duplex: "half"
+      }, upstreamAuth);
+      res.statusCode = upstreamRes.status;
+      res.statusMessage = upstreamRes.statusText;
+      copyResponseHeaders(upstreamRes.headers, res);
+      if (!upstreamRes.body || req.method === "HEAD") {
+        res.end();
+        return;
+      }
+      Readable.fromWeb(upstreamRes.body).pipe(res);
+    } catch (err) {
+      res.writeHead(502, { "content-type": "application/json" });
+      res.end(JSON.stringify({ error: "upstream registry proxy failed", detail: err instanceof Error ? err.message : String(err) }));
+    }
+  });
+}
+async function runRegistryProxy(options = registryProxyOptionsFromEnv()) {
+  const server = createRegistryProxyServer(options);
+  await new Promise((resolve) => server.listen(options.port, options.host, resolve));
+  console.log(`exe-registry-proxy listening on ${options.host ?? "0.0.0.0"}:${options.port}`);
+  console.log(`proxying /v2/${options.allowedNamespace ?? "askexe"}/* -> ${options.upstream ?? "https://ghcr.io"}`);
+}
+
+export {
+  parsePullTokens,
+  registryProxyOptionsFromEnv,
+  assertRegistryProxyConfig,
+  createRegistryProxyServer,
+  runRegistryProxy
+};

package/dist/chunk-TMEE7AT7.js

@@ -0,0 +1,72 @@
+import {
+  checkReadPathSafety
+} from "./chunk-NGVOA6ZQ.js";
+
+// src/runtime/tools/file-read.ts
+import fs from "fs/promises";
+import path from "path";
+import { z } from "zod";
+var inputSchema = z.object({
+  file_path: z.string(),
+  offset: z.number().optional(),
+  limit: z.number().optional()
+});
+var DEFAULT_LIMIT = 2e3;
+var FileReadTool = {
+  name: "file_read",
+  description: "Read a file from disk",
+  inputSchema,
+  isReadOnly: true,
+  async checkPermissions(input) {
+    const safety = checkReadPathSafety(input.file_path);
+    if (!safety.safe) {
+      return {
+        behavior: "deny",
+        reason: safety.reason ?? "Read blocked by safety check",
+        bypassImmune: true
+      };
+    }
+    return { behavior: "allow" };
+  },
+  async call(input, context) {
+    const filePath = path.isAbsolute(input.file_path) ? input.file_path : path.resolve(context.cwd, input.file_path);
+    let stat;
+    try {
+      stat = await fs.stat(filePath);
+    } catch {
+      return { content: `File not found: ${filePath}`, isError: true };
+    }
+    if (stat.size > 0) {
+      const sample = Buffer.alloc(512);
+      const fh = await fs.open(filePath, "r");
+      try {
+        const { bytesRead } = await fh.read(sample, 0, 512, 0);
+        const slice = sample.subarray(0, bytesRead);
+        if (isBinary(slice)) {
+          return {
+            content: `Binary file (${stat.size} bytes): ${filePath}`
+          };
+        }
+      } finally {
+        await fh.close();
+      }
+    }
+    const raw = await fs.readFile(filePath, "utf-8");
+    const allLines = raw.split("\n");
+    const offset = input.offset ?? 0;
+    const limit = input.limit ?? DEFAULT_LIMIT;
+    const lines = allLines.slice(offset, offset + limit);
+    const numbered = lines.map((line, i) => `${String(offset + i + 1).padStart(6)}	${line}`).join("\n");
+    return { content: numbered };
+  }
+};
+function isBinary(buf) {
+  for (let i = 0; i < buf.length; i++) {
+    if (buf[i] === 0) return true;
+  }
+  return false;
+}
+
+export {
+  FileReadTool
+};