openfox 2.0.124 → 2.0.126

package/dist/{chunk-3NMLSANH.js → chunk-Y3BSBKHY.js}

@@ -12,15 +12,28 @@ import {
 // src/server/git/workspace.ts
 import { spawn, execSync } from "child_process";
 import { mkdir as mkdir2, rm as rm2 } from "fs/promises";
-import { resolve as resolve2, join as join2, isAbsolute } from "path";
+import { resolve as resolve2, join as join3, isAbsolute } from "path";
 import { homedir, platform } from "os";
 
+// src/server/utils/fs.ts
+import { stat } from "fs/promises";
+import { join } from "path";
+async function isDirectoryEntry(parent, entry) {
+  if (entry.isDirectory()) return true;
+  if (!entry.isSymbolicLink()) return false;
+  try {
+    return (await stat(join(parent, entry.name))).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
 // src/server/git/workspace-config.ts
 import { readFile, writeFile, mkdir, rm } from "fs/promises";
-import { resolve, join } from "path";
+import { resolve, join as join2 } from "path";
 var CONFIG_FILENAME = ".openfox/workspace.json";
 function getConfigPath(workdir) {
-  return join(resolve(workdir), CONFIG_FILENAME);
+  return join2(resolve(workdir), CONFIG_FILENAME);
 }
 async function loadWorkspaceConfig(workdir) {
   try {
@@ -50,7 +63,7 @@ async function saveWorkspaceConfig(workdir, config) {
     return;
   }
   const resolved = resolve(workdir);
-  const dirPath = join(resolved, ".openfox");
+  const dirPath = join2(resolved, ".openfox");
   await mkdir(dirPath, { recursive: true });
   await writeFile(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
 }
@@ -90,11 +103,11 @@ function getGlobalDataDir() {
   const home = homedir();
   switch (platform()) {
     case "darwin":
-      return join2(home, "Library", "Application Support", `openfox${suffix}`);
+      return join3(home, "Library", "Application Support", `openfox${suffix}`);
     case "win32":
-      return join2(process.env["LOCALAPPDATA"] ?? join2(home, "AppData", "Local"), `openfox${suffix}`);
+      return join3(process.env["LOCALAPPDATA"] ?? join3(home, "AppData", "Local"), `openfox${suffix}`);
     default:
-      return join2(process.env["XDG_DATA_HOME"] ?? join2(home, ".local", "share"), `openfox${suffix}`);
+      return join3(process.env["XDG_DATA_HOME"] ?? join3(home, ".local", "share"), `openfox${suffix}`);
   }
 }
 async function getWorkspacesDir(projectName, projectDir) {
@@ -102,10 +115,10 @@ async function getWorkspacesDir(projectName, projectDir) {
   if (project?.workspaceRootDir) {
     return isAbsolute(project.workspaceRootDir) ? project.workspaceRootDir : resolve2(projectDir, project.workspaceRootDir);
   }
-  return join2(getGlobalDataDir(), "workspaces", projectName);
+  return join3(getGlobalDataDir(), "workspaces", projectName);
 }
 function getDefaultGlobalWorkspacesDir(projectName) {
-  return join2(getGlobalDataDir(), "workspaces", projectName);
+  return join3(getGlobalDataDir(), "workspaces", projectName);
 }
 function getGitBranch(cwd) {
   return captureStdout(cwd, ["rev-parse", "--abbrev-ref", "HEAD"]).then((r) => r?.trim() ?? null);
@@ -208,7 +221,7 @@ async function workspaceExists(projectName, name, projectDir) {
   const wsPath = resolve2(dir, name);
   const st = await statSafe(wsPath);
   if (!st?.isDirectory()) return false;
-  const gitDir = join2(wsPath, ".git");
+  const gitDir = join3(wsPath, ".git");
   const gitSt = await statSafe(gitDir);
   return gitSt?.isDirectory() ?? false;
 }
@@ -219,7 +232,7 @@ async function listWorkspaces(projectName, projectDir) {
     const entries = await readdir(dir, { withFileTypes: true });
     const workspaces = [];
     for (const entry of entries) {
-      if (entry.isDirectory()) {
+      if (await isDirectoryEntry(dir, entry)) {
         const wsPath = resolve2(dir, entry.name);
         const branch = await getGitBranch(wsPath);
         workspaces.push({ path: wsPath, name: entry.name, branch });
@@ -236,7 +249,7 @@ async function ensureWorkspace(projectDir, name, projectName, branch, sourceBran
   await mkdir2(workspacesDir, { recursive: true });
   const existing = await statSafe(wsPath);
   if (existing?.isDirectory()) {
-    const gitDir = join2(wsPath, ".git");
+    const gitDir = join3(wsPath, ".git");
     const gitStat = await statSafe(gitDir);
     if (!gitStat?.isDirectory()) {
       throw new Error("Existing path is not a valid workspace: " + wsPath);
@@ -290,9 +303,9 @@ async function deleteWorkspace(projectName, name, projectDir) {
   logger.info("Deleted workspace", { projectName, name, path: wsPath });
 }
 async function isGitRepository(cwd) {
-  const { stat } = await import("fs/promises");
+  const { stat: stat2 } = await import("fs/promises");
   try {
-    const st = await stat(join2(cwd, ".git"));
+    const st = await stat2(join3(cwd, ".git"));
     if (st.isDirectory()) return true;
   } catch {
   }
@@ -301,14 +314,15 @@ async function isGitRepository(cwd) {
 }
 async function statSafe(p) {
   try {
-    const { stat } = await import("fs/promises");
-    return await stat(p);
+    const { stat: stat2 } = await import("fs/promises");
+    return await stat2(p);
   } catch {
     return null;
   }
 }
 
 export {
+  isDirectoryEntry,
   loadWorkspaceConfig,
   saveWorkspaceConfig,
   runGit,
@@ -333,4 +347,4 @@ export {
   deleteWorkspace,
   isGitRepository
 };
-//# sourceMappingURL=chunk-3NMLSANH.js.map
+//# sourceMappingURL=chunk-Y3BSBKHY.js.map

package/dist/chunk-ZFNBATE3.js

@@ -0,0 +1,196 @@
+import {
+  SETTINGS_KEYS,
+  getSetting
+} from "./chunk-N2Q3KYWM.js";
+import {
+  logger
+} from "./chunk-K44MW7JJ.js";
+
+// src/server/utils/errors.ts
+var OpenFoxError = class extends Error {
+  constructor(message, code, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "OpenFoxError";
+  }
+  code;
+  details;
+};
+var SessionNotFoundError = class extends OpenFoxError {
+  constructor(sessionId) {
+    super(`Session not found: ${sessionId}`, "SESSION_NOT_FOUND", { sessionId });
+    this.name = "SessionNotFoundError";
+  }
+};
+var LLMError = class extends OpenFoxError {
+  constructor(message, details) {
+    super(message, "LLM_ERROR", details);
+    this.name = "LLMError";
+  }
+};
+var WorkspaceInUseError = class extends OpenFoxError {
+  constructor(message, conflictingSessionIds) {
+    super(message, "WORKSPACE_IN_USE");
+    this.conflictingSessionIds = conflictingSessionIds;
+    this.name = "WorkspaceInUseError";
+  }
+  conflictingSessionIds;
+};
+
+// src/server/llm/http-shared.ts
+var DONE = /* @__PURE__ */ Symbol("done");
+var ChatHttpClient = class {
+  async post(params, options) {
+    const { url, headers, body } = this.buildRequest(params);
+    logger.debug("HTTP request to LLM", { url, bodyKeys: Object.keys(params) });
+    return postJson(url, headers, body, options);
+  }
+  async createChatCompletion(params, options, returnRaw) {
+    const response = await this.post(params, options);
+    return parseCompletionResponse(response, (data) => this.parseNonStreaming(data), returnRaw);
+  }
+  createChatCompletionStream(params, options) {
+    const parseStreamLine = this.parseStreamLine.bind(this);
+    const responsePromise = this.post(params, options);
+    async function* generate() {
+      const response = await responsePromise;
+      for await (const trimmed of readResponseLines(response)) {
+        const chunk = parseStreamLine(trimmed);
+        if (chunk === null) continue;
+        if (chunk === DONE) return;
+        yield chunk;
+      }
+    }
+    return generate();
+  }
+};
+async function postJson(url, headers, body, options) {
+  const response = await fetch(url, {
+    method: "POST",
+    headers,
+    body,
+    signal: options?.signal ?? null
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new LLMError(`HTTP ${response.status}: ${errorText}`);
+  }
+  return response;
+}
+async function parseCompletionResponse(response, parse, returnRaw) {
+  const rawText = await response.text();
+  try {
+    const mapped = parse(JSON.parse(rawText));
+    if (returnRaw) {
+      return { ...mapped, raw: rawText };
+    }
+    return mapped;
+  } catch (error) {
+    throw new LLMError(`Failed to parse response: ${error instanceof Error ? error.message : "Unknown error"}`);
+  }
+}
+async function* readResponseLines(response) {
+  if (!response.body) {
+    throw new LLMError("No response body for streaming");
+  }
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed) yield trimmed;
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+
+// src/server/llm/proxy.ts
+import { fetch as undiciFetch, ProxyAgent } from "undici";
+var _cachedProxyUrl;
+var _cachedAgent;
+function getProxyAgent() {
+  const proxyUrl = getSetting(SETTINGS_KEYS.PROXY_URL) ?? void 0;
+  if (!proxyUrl) {
+    if (_cachedAgent) {
+      _cachedAgent.destroy().catch((err) => {
+        logger.warn("[proxy] Failed to destroy old proxy agent", { error: err });
+      });
+      _cachedAgent = void 0;
+      _cachedProxyUrl = void 0;
+    }
+    return void 0;
+  }
+  if (proxyUrl !== _cachedProxyUrl) {
+    if (_cachedAgent) {
+      _cachedAgent.destroy().catch((err) => {
+        logger.warn("[proxy] Failed to destroy old proxy agent", { error: err });
+      });
+    }
+    _cachedProxyUrl = proxyUrl;
+    _cachedAgent = new ProxyAgent({ uri: proxyUrl, requestTls: { rejectUnauthorized: false } });
+    logger.info("[proxy] Proxy agent created");
+  }
+  return _cachedAgent;
+}
+var _originalFetch = globalThis.fetch;
+globalThis.fetch = function(input, init) {
+  const agent = getProxyAgent();
+  if (agent) {
+    return undiciFetch(input, { ...init, dispatcher: agent });
+  }
+  return _originalFetch(input, init);
+};
+
+// src/server/llm/http-client.ts
+var OpenAIHttpClient = class extends ChatHttpClient {
+  baseURL;
+  apiKey;
+  constructor(options) {
+    super();
+    this.baseURL = options.baseURL;
+    this.apiKey = options.apiKey;
+  }
+  buildRequest(params) {
+    return {
+      url: `${this.baseURL}/chat/completions`,
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.apiKey}`
+      },
+      body: JSON.stringify(params)
+    };
+  }
+  parseNonStreaming(data) {
+    return data;
+  }
+  parseStreamLine(trimmed) {
+    if (!trimmed.startsWith("data: ")) return null;
+    const data = trimmed.slice(6);
+    if (data === "[DONE]") return DONE;
+    try {
+      return JSON.parse(data);
+    } catch (error) {
+      logger.warn("Failed to parse SSE chunk", { data, error });
+      return null;
+    }
+  }
+};
+
+export {
+  SessionNotFoundError,
+  LLMError,
+  WorkspaceInUseError,
+  ChatHttpClient,
+  OpenAIHttpClient
+};
+//# sourceMappingURL=chunk-ZFNBATE3.js.map