@mndrk/agx 2.0.26 → 2.0.33

package/cloud-runtime/standalone/lib/cli-runner.ts

@@ -1,6 +1,9 @@
 import { spawn, spawnSync } from "child_process";
+import fs from "fs";
+import path from "path";
 import type { ChatProvider } from "./types";
 import { createCliChunkSanitizer } from "./sanitize";
+import { writeDebugLog } from "./debug-log";
 
 const isNonEmptyString = (value: unknown): value is string =>
   typeof value === "string" && value.trim().length > 0;
@@ -313,6 +316,17 @@ const createThoughtFilterParser = (
 
 // Command builders
 
+// Keep chat execution on the AGX wrapper for providers AGX knows about.
+// Do not add direct provider attempts for these unless AGX itself loses the
+// ability to launch that provider. The wrapper is where unattended behavior,
+// approval bypass mapping, and future safety policy live.
+const AGX_WRAPPED_PROVIDERS: ReadonlySet<ChatProvider> = new Set([
+  "claude",
+  "gemini",
+  "ollama",
+  "codex",
+]);
+
 function providerNativeCommand({
   provider,
   model,
@@ -399,10 +413,12 @@ function agxCommandForProvider({
   provider,
   model,
   prompt,
+  passthroughArgs,
 }: {
   provider: ChatProvider;
   model: string | null;
   prompt: string;
+  passthroughArgs?: string[];
 }): {
   command: string;
   args: string[];
@@ -410,9 +426,133 @@ function agxCommandForProvider({
 } {
   const args = [provider, "-y", "--print", "--prompt", prompt];
   if (model) args.push("--model", model);
+  if (passthroughArgs && passthroughArgs.length > 0) {
+    args.push("--", ...passthroughArgs);
+  }
   return { command: "agx", args, parser: "raw" };
 }
 
+function resolveBundledCliPath(): string | null {
+  const explicit = process.env.AGX_CLI_PATH?.trim();
+  if (explicit && fs.existsSync(explicit)) return explicit;
+
+  const candidates = [
+    path.resolve(process.cwd(), "..", "cli", "index.js"),
+    path.resolve(__dirname, "..", "cli", "index.js"),
+    path.resolve(process.execPath, "..", "..", "Resources", "cli", "index.js"),
+  ];
+
+  for (const candidate of candidates) {
+    if (fs.existsSync(candidate)) {
+      return candidate;
+    }
+  }
+
+  return null;
+}
+
+type CliAttempt = {
+  command: string;
+  args: string[];
+  parser: "raw" | "claude-stream-json" | "codex-json" | "gemini-stream-json";
+  filterThoughts?: boolean;
+  env?: Record<string, string>;
+};
+
+export function buildCliAttempts(
+  {
+    provider,
+    model,
+    prompt,
+    systemPrompt,
+    passthroughArgs,
+  }: {
+    provider: ChatProvider;
+    model: string | null;
+    prompt: string;
+    systemPrompt?: string;
+    passthroughArgs?: string[];
+  },
+  deps: {
+    commandExists?: (bin: string) => boolean;
+    bundledCliPath?: string | null;
+  } = {}
+): CliAttempt[] {
+  const exists = deps.commandExists ?? commandExists;
+  const bundledCliPath =
+    deps.bundledCliPath === undefined ? resolveBundledCliPath() : deps.bundledCliPath;
+  const attempts: CliAttempt[] = [];
+
+  const agxPrompt = systemPrompt ? `${systemPrompt}\n\n${prompt}` : prompt;
+  if (AGX_WRAPPED_PROVIDERS.has(provider)) {
+    // If the AGX wrapper does not expose a provider-specific flag yet, pass it
+    // through after `--` instead of reintroducing direct provider execution here.
+    const bundledAgx = bundledAgxCommandForProvider({
+      provider,
+      model,
+      prompt: agxPrompt,
+      cliPath: bundledCliPath,
+      passthroughArgs,
+    });
+    if (bundledAgx) {
+      attempts.push(bundledAgx);
+    }
+
+    if (exists("agx")) {
+      attempts.push(
+        agxCommandForProvider({
+          provider,
+          model,
+          prompt: agxPrompt,
+          passthroughArgs,
+        })
+      );
+    }
+
+    return attempts;
+  }
+
+  const nativeAttempt = providerNativeCommand({
+    provider,
+    model,
+    prompt,
+    systemPrompt,
+  });
+  if (nativeAttempt && exists(nativeAttempt.command)) {
+    attempts.push(nativeAttempt);
+  }
+
+  return attempts;
+}
+
+function bundledAgxCommandForProvider({
+  provider,
+  model,
+  prompt,
+  cliPath,
+  passthroughArgs,
+}: {
+  provider: ChatProvider;
+  model: string | null;
+  prompt: string;
+  cliPath?: string | null;
+  passthroughArgs?: string[];
+}): {
+  command: string;
+  args: string[];
+  parser: "raw";
+} | null {
+  const resolvedCliPath = cliPath === undefined ? resolveBundledCliPath() : cliPath;
+  if (!resolvedCliPath) return null;
+
+  const args = [resolvedCliPath, provider, "-y", "--print", "--prompt", prompt];
+  if (model) args.push("--model", model);
+  if (passthroughArgs && passthroughArgs.length > 0) {
+    args.push("--", ...passthroughArgs);
+  }
+  return { command: process.execPath, args, parser: "raw" };
+}
+
 // Core runner
 
 async function runCommandStreamed({
@@ -435,6 +575,13 @@ async function runCommandStreamed({
   env?: Record<string, string>;
 }): Promise<void> {
   await new Promise<void>((resolve, reject) => {
+    writeDebugLog("cli-runner.spawn", {
+      command,
+      args,
+      timeoutMs,
+      bundledCliPath: resolveBundledCliPath(),
+      isElectron: process.env.AGX_ELECTRON || null,
+    });
     if (onLog) onLog("stderr", `$ ${command} ${args.map(a => a.length > 80 ? a.slice(0, 80) + '…' : a).join(' ')}\n`);
     const child = spawn(command, args, {
       stdio: ["ignore", "pipe", "pipe"],
@@ -455,6 +602,11 @@ async function runCommandStreamed({
     };
 
     const onAbort = () => {
+      writeDebugLog("cli-runner.abort", {
+        command,
+        args,
+        pid: child.pid ?? null,
+      });
       child.kill("SIGTERM");
       finalize(new Error("Chat request aborted."));
     };
@@ -462,9 +614,20 @@ async function runCommandStreamed({
     if (signal) signal.addEventListener("abort", onAbort, { once: true });
 
     if (onSpawn && child.pid) onSpawn(child.pid);
+    writeDebugLog("cli-runner.spawned", {
+      command,
+      args,
+      pid: child.pid ?? null,
+    });
 
     const timer = setTimeout(() => {
       timedOut = true;
+      writeDebugLog("cli-runner.timeout", {
+        command,
+        args,
+        pid: child.pid ?? null,
+        timeoutMs,
+      });
       child.kill("SIGKILL");
       finalize(new Error(`CLI request timed out after ${timeoutMs}ms.`));
     }, timeoutMs);
@@ -482,10 +645,25 @@ async function runCommandStreamed({
       if (onLog) onLog("stderr", str);
     });
 
-    child.on("error", (error) => finalize(error));
+    child.on("error", (error) => {
+      writeDebugLog("cli-runner.process_error", {
+        command,
+        args,
+        pid: child.pid ?? null,
+        error,
+      });
+      finalize(error);
+    });
 
     child.on("close", (code, childSignal) => {
       if (done || timedOut) return;
+      writeDebugLog("cli-runner.close", {
+        command,
+        args,
+        pid: child.pid ?? null,
+        code: code ?? null,
+        signal: childSignal ?? null,
+      });
       if (code === 0) {
         finalize();
         return;
@@ -507,6 +685,7 @@ export async function runCliResponse({
   self,
   skills,
   systemContext,
+  passthroughArgs,
   signal,
   onDelta,
   onLog,
@@ -519,6 +698,7 @@ export async function runCliResponse({
   self?: string;
   skills?: string;
   systemContext?: string;
+  passthroughArgs?: string[];
   signal?: AbortSignal;
   onDelta: (chunk: string) => void;
   onLog?: (stream: "stdout" | "stderr", line: string) => void;
@@ -531,27 +711,27 @@ export async function runCliResponse({
     if (cleaned) onDelta(cleaned);
   };
 
-  const attempts: Array<{
-    command: string;
-    args: string[];
-    parser: "raw" | "claude-stream-json" | "codex-json" | "gemini-stream-json";
-    filterThoughts?: boolean;
-    env?: Record<string, string>;
-  }> = [];
-
   const systemParts: string[] = [];
   if (systemContext) systemParts.push(systemContext);
   if (identity) systemParts.push(`<identity>\n${identity}\n</identity>`);
   if (self) systemParts.push(`<self>\n${self}\n</self>`);
   if (skills) systemParts.push(`<skills>\n${skills}\n</skills>`);
   const systemPrompt = systemParts.length > 0 ? systemParts.join("\n\n") : undefined;
-
-  if (commandExists("agx")) {
-    const agxPrompt = systemPrompt ? `${systemPrompt}\n\n${prompt}` : prompt;
-    attempts.push(agxCommandForProvider({ provider, model, prompt: agxPrompt }));
-  }
+  const attempts = buildCliAttempts({
+    provider,
+    model,
+    prompt,
+    systemPrompt,
+    passthroughArgs,
+  });
 
   if (attempts.length === 0) {
+    writeDebugLog("cli-runner.no_attempts", {
+      provider,
+      model,
+      bundledCliPath: resolveBundledCliPath(),
+      isElectron: process.env.AGX_ELECTRON || null,
+    });
     throw new Error(
       `No CLI runner available for provider "${provider}". Install agx or provider CLI.`
     );
@@ -559,6 +739,13 @@ export async function runCliResponse({
 
   let lastError: Error | null = null;
   for (const attempt of attempts) {
+    writeDebugLog("cli-runner.attempt", {
+      provider,
+      model,
+      command: attempt.command,
+      args: attempt.args,
+      parser: attempt.parser,
+    });
     const baseParser =
       attempt.parser === "claude-stream-json"
         ? createClaudeStreamJsonParser(wrappedOnDelta)
@@ -583,9 +770,20 @@ export async function runCliResponse({
         env: attempt.env,
       });
       parser.flush();
+      writeDebugLog("cli-runner.success", {
+        provider,
+        model,
+        command: attempt.command,
+      });
       return;
     } catch (error) {
       lastError = error instanceof Error ? error : new Error(String(error));
+      writeDebugLog("cli-runner.failure", {
+        provider,
+        model,
+        command: attempt.command,
+        error: lastError,
+      });
     }
   }
 

package/cloud-runtime/standalone/lib/db.ts

@@ -2611,7 +2611,7 @@ export async function getProjectThreads(projectId: string): Promise<ProjectThrea
     .from("project_threads")
     .select("*")
     .eq("project_id", projectId)
-    .order("created_at", { ascending: false });
+    .order("created_at", { ascending: true });
 
   if (error) {
     if (isMissingRelationError(error, "project_threads")) return [];

package/cloud-runtime/standalone/lib/debug-log.ts

@@ -0,0 +1,48 @@
+import fs from "fs";
+import os from "os";
+import path from "path";
+
+const AGX_DATA_DIR = process.env.AGX_DATA_DIR || path.join(os.homedir(), ".agx");
+const DEBUG_LOG_PATH =
+  process.env.AGX_DEBUG_LOG_PATH ||
+  path.join(AGX_DATA_DIR, "logs", "desktop-chat-debug.log");
+
+function ensureLogDir() {
+  fs.mkdirSync(path.dirname(DEBUG_LOG_PATH), { recursive: true });
+}
+
+function safeReplacer(_key: string, value: unknown): unknown {
+  if (value instanceof Error) {
+    return {
+      name: value.name,
+      message: value.message,
+      stack: value.stack,
+    };
+  }
+  if (typeof value === "string" && value.length > 2000) {
+    return `${value.slice(0, 2000)}...<truncated>`;
+  }
+  return value;
+}
+
+export function getDebugLogPath(): string {
+  return DEBUG_LOG_PATH;
+}
+
+export function writeDebugLog(event: string, payload?: Record<string, unknown>) {
+  try {
+    ensureLogDir();
+    const line = JSON.stringify(
+      {
+        ts: new Date().toISOString(),
+        pid: process.pid,
+        event,
+        ...(payload ? { payload } : {}),
+      },
+      safeReplacer
+    );
+    fs.appendFileSync(DEBUG_LOG_PATH, `${line}\n`, "utf8");
+  } catch {
+    // Debug logging must never break the request path.
+  }
+}