@love-moon/conductor-cli 0.2.39 → 0.2.40

package/src/handoff-log-mask.js

@@ -0,0 +1,64 @@
+// Small helpers for masking handoff-share URLs in logs / error messages /
+// task status summaries. Extracted into a dependency-free module so they
+// can be unit-tested without loading the rest of the daemon (which would
+// otherwise require @love-moon/conductor-sdk and its build artifacts).
+
+// The handoff URL embeds a bearer-style share token in its path. We mask it
+// before writing to logs so daemon log files / `ps`-visible output don't leak
+// a 24h read-grant for the entire transcript. The full URL still goes into
+// the spawned CLI's argv (necessarily — that's how the AI fetches it), but
+// the persistent log surface is safe.
+//
+// The character class `[^/?#\s]+` stops the token at query-string, fragment,
+// or whitespace boundaries, so URLs like `.../share/<tok>/plain?x=1` or
+// `.../share/<tok>/plain#foo` are still masked instead of leaking verbatim.
+// The trailing portion (query/fragment/path tail) is preserved after masking.
+export function maskHandoffUrlForLogs(value) {
+  if (typeof value !== "string" || !value) {
+    return value;
+  }
+  return value.replace(/\/share\/([^/?#\s]+)/g, (_, token) => {
+    const tail = token.length > 4 ? token.slice(-4) : token;
+    return `/share/<masked:…${tail}>`;
+  });
+}
+
+// Scrub any handoff URL embedded in an error message before surfacing it via
+// logs or task status summaries. Belt-and-suspenders for the case where an
+// internal error stringifies the outbox payload.
+//
+// Metadata (`name`, `code`, `cause`, any own props the caller attached) is
+// preserved on the clone so downstream consumers that switch on those fields
+// (retry policies, status mappers) keep working after scrubbing. The
+// prototype chain is also preserved so `instanceof` checks survive.
+//
+// Stack frames in some runtimes embed argument strings in the source
+// snippet; the stack is passed through the same masker so a URL that
+// happens to appear in a frame cannot leak through the log that prints
+// the stack.
+export function maskErrorForLogs(error) {
+  if (!error) {
+    return error;
+  }
+  const message = typeof error === "string" ? error : error.message;
+  if (typeof message !== "string") {
+    return error;
+  }
+  const masked = maskHandoffUrlForLogs(message);
+  if (masked === message) {
+    return error;
+  }
+  if (typeof error === "string") {
+    return masked;
+  }
+  const proto = Object.getPrototypeOf(error) || Error.prototype;
+  const clone = Object.create(proto);
+  Object.assign(clone, error);
+  clone.message = masked;
+  clone.name = error.name || clone.name || "Error";
+  clone.stack =
+    typeof error.stack === "string"
+      ? maskHandoffUrlForLogs(error.stack)
+      : error.stack;
+  return clone;
+}

package/src/runtime-backends.js

@@ -4,8 +4,10 @@ import { pathToFileURL } from "node:url";
 
 import yaml from "js-yaml";
 
-const BUILT_IN_RUNTIME_BACKENDS = ["codex", "claude", "kimi", "opencode"];
+const BUILT_IN_RUNTIME_BACKENDS = ["codex", "claude", "kimi", "opencode", "copilot"];
 const BUILT_IN_RUNTIME_BACKEND_SET = new Set(BUILT_IN_RUNTIME_BACKENDS);
+const COMMAND_OPTIONAL_BUILT_IN_RUNTIME_BACKENDS = ["copilot"];
+const COMMAND_OPTIONAL_BUILT_IN_RUNTIME_BACKEND_SET = new Set(COMMAND_OPTIONAL_BUILT_IN_RUNTIME_BACKENDS);
 const LEGACY_RUNTIME_BACKEND_ALIASES = new Set([
   "code",
   "claude-code",
@@ -96,7 +98,7 @@ function stripExecutableSuffix(name) {
     .replace(/\.(cmd|bat|exe)$/i, "");
 }
 
-function parseCommandParts(commandLine) {
+export function parseCommandParts(commandLine) {
   const input = String(commandLine || "").trim();
   if (!input) {
     return { command: "", args: [], parts: [] };
@@ -105,29 +107,39 @@ function parseCommandParts(commandLine) {
   const parts = [];
   let current = "";
   let quote = "";
-  let escaping = false;
   let tokenStarted = false;
 
-  for (const char of input) {
-    if (escaping) {
-      current += char;
-      tokenStarted = true;
-      escaping = false;
-      continue;
-    }
+  for (let index = 0; index < input.length; index += 1) {
+    const char = input[index];
+    const nextChar = input[index + 1];
 
-    if (char === "\\") {
-      escaping = true;
+    if (quote === "'") {
+      if (char === "'") {
+        quote = "";
+      } else {
+        current += char;
+      }
       tokenStarted = true;
       continue;
     }
 
-    if (quote) {
-      if (char === quote) {
+    if (quote === "\"") {
+      if (char === "\"") {
         quote = "";
-      } else {
-        current += char;
+        continue;
       }
+      if (char === "\\") {
+        if (nextChar === "\"" || nextChar === "\\") {
+          current += nextChar;
+          tokenStarted = true;
+          index += 1;
+          continue;
+        }
+        current += "\\";
+        tokenStarted = true;
+        continue;
+      }
+      current += char;
       tokenStarted = true;
       continue;
     }
@@ -138,6 +150,18 @@ function parseCommandParts(commandLine) {
       continue;
     }
 
+    if (char === "\\") {
+      if (nextChar && (/\s/.test(nextChar) || nextChar === "\"" || nextChar === "'" || nextChar === "\\")) {
+        current += nextChar;
+        tokenStarted = true;
+        index += 1;
+        continue;
+      }
+      current += "\\";
+      tokenStarted = true;
+      continue;
+    }
+
     if (/\s/.test(char)) {
       if (tokenStarted) {
         parts.push(current);
@@ -151,6 +175,10 @@ function parseCommandParts(commandLine) {
     tokenStarted = true;
   }
 
+  if (quote) {
+    throw new Error(`Invalid command line: unterminated ${quote === "\"" ? "double" : "single"} quote`);
+  }
+
   if (tokenStarted) {
     parts.push(current);
   }
@@ -264,6 +292,10 @@ export function isBuiltInRuntimeBackend(backend) {
   return BUILT_IN_RUNTIME_BACKEND_SET.has(normalizeRuntimeBackendName(backend));
 }
 
+export function isCommandOptionalBuiltInRuntimeBackend(backend) {
+  return COMMAND_OPTIONAL_BUILT_IN_RUNTIME_BACKEND_SET.has(normalizeRuntimeBackendName(backend));
+}
+
 function readConfigEnvValue(configFilePath, key) {
   const targetPath =
     typeof configFilePath === "string" && configFilePath.trim()
@@ -523,6 +555,14 @@ export async function resolveConfiguredRuntimeBackend(backend, allowCliList, opt
     };
   }
 
+  if (!hasConfiguredEntry && isCommandOptionalBuiltInRuntimeBackend(resolvedBackend)) {
+    return {
+      requestedBackend: normalizedBackend,
+      runtimeBackend: resolvedBackend,
+      commandLine: "",
+    };
+  }
+
   if (!hasConfiguredEntry && !isBuiltInRuntimeBackend(resolvedBackend) && await isRuntimeSupportedBackend(resolvedBackend, options)) {
     return {
       requestedBackend: normalizedBackend,
@@ -586,12 +626,22 @@ export async function listAdvertisedBackends(allowCliList, options = {}) {
   const externalBackends = discoveredExternalBackends.filter(
     (backend) => !shadowedExternalBackends.has(backend) && !explicitlyConfiguredBackends.has(backend),
   );
-  const supportedBackends = [...new Set([...advertisedConfiguredBackends, ...externalBackends])];
 
   for (const backend of externalBackends) {
     runtimeBackendMap[backend] = backend;
   }
 
+  const commandOptionalBuiltIns = BUILT_IN_RUNTIME_BACKENDS.filter(
+    (backend) => isCommandOptionalBuiltInRuntimeBackend(backend) && !runtimeBackendMap[backend],
+  );
+  for (const backend of commandOptionalBuiltIns) {
+    runtimeBackendMap[backend] = backend;
+  }
+
+  const supportedBackends = [
+    ...new Set([...advertisedConfiguredBackends, ...externalBackends, ...commandOptionalBuiltIns]),
+  ];
+
   return {
     configuredBackends: advertisedConfiguredBackends,
     externalBackends,

package/src/serve-ai/adapter.js

@@ -0,0 +1,383 @@
+import { randomUUID } from "node:crypto";
+
+function normalizeRole(role) {
+  const normalized = String(role || "").trim().toLowerCase();
+  return normalized || "user";
+}
+
+function extractImageUrlFromPart(part) {
+  if (!part || typeof part !== "object") {
+    return "";
+  }
+  if (part.type === "image_url") {
+    if (typeof part.image_url === "string") {
+      return part.image_url.trim();
+    }
+    if (part.image_url && typeof part.image_url === "object" && typeof part.image_url.url === "string") {
+      return part.image_url.url.trim();
+    }
+  }
+  if (part.type === "input_image") {
+    if (typeof part.image_url === "string") {
+      return part.image_url.trim();
+    }
+    if (typeof part.url === "string") {
+      return part.url.trim();
+    }
+  }
+  return "";
+}
+
+function extractTextFromPart(part) {
+  if (!part || typeof part !== "object") {
+    return "";
+  }
+  if (part.type === "text" && typeof part.text === "string") {
+    return part.text;
+  }
+  if (part.type === "input_text" && typeof part.text === "string") {
+    return part.text;
+  }
+  return "";
+}
+
+export function extractMessageParts(content) {
+  if (typeof content === "string") {
+    return {
+      text: content.trim(),
+      imageUrls: [],
+    };
+  }
+
+  if (!Array.isArray(content)) {
+    return {
+      text: "",
+      imageUrls: [],
+    };
+  }
+
+  const texts = [];
+  const imageUrls = [];
+  for (const part of content) {
+    const text = extractTextFromPart(part);
+    if (text) {
+      texts.push(text);
+    }
+    const imageUrl = extractImageUrlFromPart(part);
+    if (imageUrl) {
+      imageUrls.push(imageUrl);
+    }
+  }
+
+  return {
+    text: texts.join("").trim(),
+    imageUrls,
+  };
+}
+
+function serializeMessageForHistory(message) {
+  const role = normalizeRole(message?.role);
+  const { text, imageUrls } = extractMessageParts(message?.content);
+  const historyRole = role === "assistant" ? "assistant" : "user";
+  const segments = [];
+
+  if (role === "system") {
+    segments.push("[System]");
+  } else if (role === "tool") {
+    segments.push("[Tool]");
+  }
+
+  if (text) {
+    segments.push(text);
+  }
+
+  if (imageUrls.length > 0) {
+    segments.push(
+      imageUrls.length === 1
+        ? "[Attached image omitted from prior turn]"
+        : `[${imageUrls.length} attached images omitted from prior turn]`,
+    );
+  }
+
+  const content = segments.filter(Boolean).join("\n\n").trim();
+  return content ? { role: historyRole, content } : null;
+}
+
+export function buildChatTurn(messages) {
+  const normalizedMessages = Array.isArray(messages) ? messages : [];
+  if (normalizedMessages.length === 0) {
+    throw new Error("messages must be a non-empty array");
+  }
+
+  const history = [];
+  for (const message of normalizedMessages.slice(0, -1)) {
+    const entry = serializeMessageForHistory(message);
+    if (entry) {
+      history.push(entry);
+    }
+  }
+
+  const lastMessage = normalizedMessages.at(-1);
+  const lastRole = normalizeRole(lastMessage?.role);
+  const { text, imageUrls } = extractMessageParts(lastMessage?.content);
+
+  let promptText = text;
+  if (lastRole === "system") {
+    promptText = promptText ? `[System]\n\n${promptText}` : "[System]";
+  } else if (lastRole === "assistant") {
+    promptText = promptText ? `[Assistant]\n\n${promptText}` : "[Assistant]";
+  } else if (lastRole === "tool") {
+    promptText = promptText ? `[Tool]\n\n${promptText}` : "[Tool]";
+  }
+
+  if (!promptText && imageUrls.length > 0) {
+    promptText = "Analyze the attached image.";
+  }
+
+  if (!promptText) {
+    throw new Error("last message must include text or image content");
+  }
+
+  return {
+    promptText,
+    imageUrls,
+    initialHistory: history,
+  };
+}
+
+export function normalizeResponseFormat(responseFormat) {
+  if (!responseFormat || responseFormat === "text") {
+    return {
+      type: "text",
+      jsonSchema: null,
+      outputFormat: null,
+    };
+  }
+
+  if (typeof responseFormat !== "object") {
+    throw new Error("response_format must be an object");
+  }
+
+  const type = String(responseFormat.type || "").trim().toLowerCase();
+  if (!type || type === "text") {
+    return {
+      type: "text",
+      jsonSchema: null,
+      outputFormat: null,
+    };
+  }
+
+  if (type === "json_object") {
+    return {
+      type,
+      jsonSchema: {
+        type: "object",
+      },
+      outputFormat: {
+        type: "json_object",
+      },
+    };
+  }
+
+  if (type === "json_schema") {
+    const jsonSchema =
+      responseFormat?.json_schema?.schema && typeof responseFormat.json_schema.schema === "object"
+        ? responseFormat.json_schema.schema
+        : responseFormat?.schema && typeof responseFormat.schema === "object"
+          ? responseFormat.schema
+          : null;
+    if (!jsonSchema) {
+      throw new Error("response_format.json_schema.schema is required");
+    }
+    return {
+      type,
+      jsonSchema,
+      outputFormat: {
+        type: "json_schema",
+        schema: jsonSchema,
+      },
+    };
+  }
+
+  throw new Error(`unsupported response_format.type: ${type}`);
+}
+
+function tryParseJson(text) {
+  try {
+    return {
+      ok: true,
+      value: JSON.parse(text),
+    };
+  } catch {
+    return {
+      ok: false,
+      value: null,
+    };
+  }
+}
+
+function unwrapJsonCodeFence(text) {
+  const normalized = String(text || "").trim();
+  const match = normalized.match(/^```(?:json)?\s*([\s\S]*?)\s*```$/i);
+  return match ? match[1].trim() : normalized;
+}
+
+function findBalancedJsonSubstring(text) {
+  const source = String(text || "");
+  for (let start = 0; start < source.length; start += 1) {
+    const opener = source[start];
+    if (opener !== "{" && opener !== "[") {
+      continue;
+    }
+
+    const stack = [opener === "{" ? "}" : "]"];
+    let inString = false;
+    let escaped = false;
+
+    for (let index = start + 1; index < source.length; index += 1) {
+      const char = source[index];
+      if (inString) {
+        if (escaped) {
+          escaped = false;
+          continue;
+        }
+        if (char === "\\") {
+          escaped = true;
+          continue;
+        }
+        if (char === "\"") {
+          inString = false;
+        }
+        continue;
+      }
+
+      if (char === "\"") {
+        inString = true;
+        continue;
+      }
+      if (char === "{") {
+        stack.push("}");
+        continue;
+      }
+      if (char === "[") {
+        stack.push("]");
+        continue;
+      }
+      if ((char === "}" || char === "]") && stack.at(-1) === char) {
+        stack.pop();
+        if (stack.length === 0) {
+          const candidate = source.slice(start, index + 1).trim();
+          const parsed = tryParseJson(candidate);
+          if (parsed.ok) {
+            return parsed.value;
+          }
+          break;
+        }
+      }
+    }
+  }
+  return null;
+}
+
+function extractStructuredOutputValue(result) {
+  if (!result || typeof result !== "object") {
+    return undefined;
+  }
+  if (
+    result.metadata &&
+    typeof result.metadata === "object" &&
+    Object.prototype.hasOwnProperty.call(result.metadata, "structuredOutput")
+  ) {
+    return result.metadata.structuredOutput;
+  }
+  return undefined;
+}
+
+function parseStructuredOutputText(text) {
+  const normalized = String(text || "").trim();
+  if (!normalized) {
+    throw new Error("structured output is empty");
+  }
+
+  const direct = tryParseJson(normalized);
+  if (direct.ok) {
+    return direct.value;
+  }
+
+  const unfenced = unwrapJsonCodeFence(normalized);
+  if (unfenced !== normalized) {
+    const fenced = tryParseJson(unfenced);
+    if (fenced.ok) {
+      return fenced.value;
+    }
+  }
+
+  const extracted = findBalancedJsonSubstring(unfenced);
+  if (extracted !== null) {
+    return extracted;
+  }
+
+  throw new Error("structured output is not valid JSON");
+}
+
+function normalizeUsage(usage) {
+  const promptTokens =
+    Number(usage?.prompt_tokens ?? usage?.input_tokens ?? usage?.inputTokens ?? usage?.input ?? 0) || 0;
+  const completionTokens =
+    Number(usage?.completion_tokens ?? usage?.output_tokens ?? usage?.outputTokens ?? usage?.output ?? 0) || 0;
+  const totalTokens =
+    Number(usage?.total_tokens ?? usage?.totalTokens ?? promptTokens + completionTokens) || 0;
+
+  return {
+    prompt_tokens: promptTokens,
+    completion_tokens: completionTokens,
+    total_tokens: totalTokens,
+  };
+}
+
+export function assertStructuredOutputText(text, responseFormat) {
+  if (!responseFormat || responseFormat.type === "text") {
+    return;
+  }
+  JSON.parse(String(text || ""));
+}
+
+export function normalizeStructuredOutputResult(result, responseFormat) {
+  if (!responseFormat || responseFormat.type === "text") {
+    return result;
+  }
+
+  const metadataStructuredOutput = extractStructuredOutputValue(result);
+  if (metadataStructuredOutput !== undefined) {
+    return {
+      ...(result && typeof result === "object" ? result : {}),
+      text: JSON.stringify(metadataStructuredOutput),
+    };
+  }
+
+  return {
+    ...(result && typeof result === "object" ? result : {}),
+    text: JSON.stringify(parseStructuredOutputText(result?.text)),
+  };
+}
+
+export function toOpenAiChatCompletion(result, { model }) {
+  const text = typeof result?.text === "string" ? result.text : "";
+  return {
+    id: `chatcmpl-${randomUUID()}`,
+    object: "chat.completion",
+    created: Math.floor(Date.now() / 1000),
+    model,
+    choices: [
+      {
+        index: 0,
+        message: {
+          role: "assistant",
+          content: text,
+        },
+        finish_reason: "stop",
+      },
+    ],
+    usage: normalizeUsage(result?.usage),
+  };
+}