@love-moon/conductor-cli 0.2.39 → 0.2.40

package/src/serve-ai/config.js

@@ -0,0 +1,133 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+import yaml from "js-yaml";
+
+export const DEFAULT_CONDUCTOR_CONFIG_BASENAME = "config.yaml";
+export const DEFAULT_SERVE_AI_CONFIG_BASENAME = "config-ai-serve.yaml";
+
+function resolvePrimaryConfigPath(configFilePath) {
+  if (typeof configFilePath === "string" && configFilePath.trim()) {
+    return path.resolve(configFilePath.trim());
+  }
+  if (typeof process.env.CONDUCTOR_CONFIG === "string" && process.env.CONDUCTOR_CONFIG.trim()) {
+    return path.resolve(process.env.CONDUCTOR_CONFIG.trim());
+  }
+  return path.join(os.homedir(), ".conductor", DEFAULT_CONDUCTOR_CONFIG_BASENAME);
+}
+
+export function resolveServeAiConfigPaths(configFilePath) {
+  const conductorConfigPath = resolvePrimaryConfigPath(configFilePath);
+  return {
+    conductorConfigPath,
+    serveAiConfigPath: path.join(path.dirname(conductorConfigPath), DEFAULT_SERVE_AI_CONFIG_BASENAME),
+  };
+}
+
+function parseYamlFile(filePath) {
+  const content = fs.readFileSync(filePath, "utf8");
+  const parsed = yaml.load(content);
+  if (parsed == null) {
+    return {};
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`Expected YAML mapping in ${filePath}`);
+  }
+  return parsed;
+}
+
+export function loadServeAiRuntimeConfig(configFilePath) {
+  const { conductorConfigPath, serveAiConfigPath } = resolveServeAiConfigPaths(configFilePath);
+  const conductorExists = fs.existsSync(conductorConfigPath);
+  const serveAiExists = fs.existsSync(serveAiConfigPath);
+
+  let activeConfigPath = conductorConfigPath;
+  let source = "conductor";
+  if (!conductorExists && serveAiExists) {
+    activeConfigPath = serveAiConfigPath;
+    source = "serve-ai";
+  }
+
+  let parsed = {};
+  if (fs.existsSync(activeConfigPath)) {
+    parsed = parseYamlFile(activeConfigPath);
+  }
+
+  return {
+    conductorConfigPath,
+    serveAiConfigPath,
+    activeConfigPath,
+    source,
+    parsed,
+    allowCliList:
+      parsed && parsed.allow_cli_list && typeof parsed.allow_cli_list === "object"
+        ? parsed.allow_cli_list
+        : {},
+    envs:
+      parsed && parsed.envs && typeof parsed.envs === "object"
+        ? parsed.envs
+        : {},
+    defaults:
+      parsed && parsed.serve_ai && typeof parsed.serve_ai === "object"
+        ? parsed.serve_ai
+        : {},
+  };
+}
+
+function normalizeOptionalString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : "";
+}
+
+export function buildServeAiConfigYaml({
+  backend = "codex",
+  host = "127.0.0.1",
+  port = 8787,
+  apiKey = "",
+} = {}) {
+  const lines = [
+    "# Dedicated config for `conductor serve-ai`.",
+    "# This file is used when the sibling config.yaml does not exist.",
+    "",
+    "serve_ai:",
+    `  host: ${yaml.dump(host).trim()}`,
+    `  port: ${Number.isFinite(Number(port)) ? Number(port) : 8787}`,
+    `  backend: ${yaml.dump(backend).trim()}`,
+  ];
+
+  const normalizedApiKey = normalizeOptionalString(apiKey);
+  if (normalizedApiKey) {
+    lines.push(`  api_key: ${yaml.dump(normalizedApiKey).trim()}`);
+  } else {
+    lines.push("  # api_key: local-dev-key");
+  }
+
+  lines.push(
+    "",
+    "# Allowed AI backends and their launch commands.",
+    "allow_cli_list:",
+    "  codex: codex",
+    "  kimi: kimi",
+    "  claude: claude",
+    "  opencode: opencode",
+    "",
+    "# Optional extra environment variables for AI SDK / backend CLIs.",
+    "# envs:",
+    "#   http_proxy: http://127.0.0.1:7890",
+    "#   https_proxy: http://127.0.0.1:7890",
+    "#   AISDK_PROVIDER_PATH: /abs/path/to/provider.js",
+    "",
+  );
+
+  return lines.join("\n");
+}
+
+export function writeServeAiConfigFile(targetPath, options = {}) {
+  const normalizedPath = path.resolve(String(targetPath || "").trim());
+  if (!normalizedPath) {
+    throw new Error("targetPath is required");
+  }
+  fs.mkdirSync(path.dirname(normalizedPath), { recursive: true });
+  fs.writeFileSync(normalizedPath, buildServeAiConfigYaml(options), "utf8");
+  return normalizedPath;
+}

package/src/serve-ai/errors.js

@@ -0,0 +1,28 @@
+export function createOpenAiErrorBody(message, { type = "invalid_request_error", param = null, code = null } = {}) {
+  return {
+    error: {
+      message: String(message || "Unknown error"),
+      type,
+      param,
+      code,
+    },
+  };
+}
+
+export function sendJson(res, statusCode, payload, extraHeaders = {}) {
+  const body = JSON.stringify(payload);
+  res.writeHead(statusCode, {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": Buffer.byteLength(body),
+    "cache-control": "no-store",
+    "access-control-allow-origin": "*",
+    "access-control-allow-headers": "authorization, content-type",
+    "access-control-allow-methods": "GET, POST, OPTIONS",
+    ...extraHeaders,
+  });
+  res.end(body);
+}
+
+export function sendOpenAiError(res, statusCode, message, options = {}) {
+  sendJson(res, statusCode, createOpenAiErrorBody(message, options));
+}

package/src/serve-ai/image-handler.js

@@ -0,0 +1,92 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+
+function inferExtensionFromMimeType(mimeType) {
+  const normalized = String(mimeType || "").trim().toLowerCase();
+  if (normalized === "image/png") return ".png";
+  if (normalized === "image/jpeg") return ".jpg";
+  if (normalized === "image/webp") return ".webp";
+  if (normalized === "image/gif") return ".gif";
+  if (normalized === "image/bmp") return ".bmp";
+  if (normalized === "image/svg+xml") return ".svg";
+  return ".bin";
+}
+
+function inferExtensionFromUrl(urlString) {
+  try {
+    const pathname = new URL(urlString).pathname || "";
+    const ext = path.extname(pathname);
+    return ext || ".bin";
+  } catch {
+    return ".bin";
+  }
+}
+
+function parseDataUri(uri) {
+  const match = String(uri || "").match(/^data:([^;,]+)?(?:;charset=[^;,]+)?;base64,(.+)$/i);
+  if (!match) {
+    return null;
+  }
+  return {
+    mimeType: match[1] || "application/octet-stream",
+    data: match[2],
+  };
+}
+
+async function writeTempFile(buffer, extension) {
+  const tempDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), "conductor-serve-ai-image-"));
+  const filePath = path.join(tempDir, `${randomUUID()}${extension || ".bin"}`);
+  await fs.promises.writeFile(filePath, buffer);
+  return {
+    filePath,
+    cleanup: async () => {
+      await fs.promises.rm(tempDir, { recursive: true, force: true }).catch(() => {});
+    },
+  };
+}
+
+async function materializeImageUrl(imageUrl, fetchImpl) {
+  const dataUri = parseDataUri(imageUrl);
+  if (dataUri) {
+    const buffer = Buffer.from(dataUri.data, "base64");
+    return writeTempFile(buffer, inferExtensionFromMimeType(dataUri.mimeType));
+  }
+
+  const response = await fetchImpl(imageUrl);
+  if (!response.ok) {
+    throw new Error(`failed to download image: HTTP ${response.status}`);
+  }
+  const arrayBuffer = await response.arrayBuffer();
+  const mimeType = response.headers.get("content-type") || "";
+  return writeTempFile(
+    Buffer.from(arrayBuffer),
+    mimeType ? inferExtensionFromMimeType(mimeType) : inferExtensionFromUrl(imageUrl),
+  );
+}
+
+export async function materializeImageInputs(imageUrls, { fetchImpl = fetch } = {}) {
+  const normalizedUrls = Array.isArray(imageUrls)
+    ? imageUrls.filter((item) => typeof item === "string" && item.trim()).map((item) => item.trim())
+    : [];
+  const files = [];
+  const cleanups = [];
+
+  try {
+    for (const imageUrl of normalizedUrls) {
+      const file = await materializeImageUrl(imageUrl, fetchImpl);
+      files.push(file.filePath);
+      cleanups.push(file.cleanup);
+    }
+    return {
+      files,
+      cleanup: async () => {
+        await Promise.allSettled(cleanups.map((fn) => fn()));
+      },
+    };
+  } catch (error) {
+    await Promise.allSettled(cleanups.map((fn) => fn()));
+    throw error;
+  }
+}