@mndrk/agx 2.0.32 → 2.0.34

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

@@ -248,6 +248,7 @@ export interface Agent {
   id: string;
   user_id: string;
   name: string;
+  title?: string;
   style: AgentStyle;
   description?: string;
   voice?: string;
@@ -2308,6 +2309,7 @@ export async function createAgent(
   input: {
     id?: string;
     name: string;
+    title?: string;
     style: AgentStyle;
     description?: string;
     voice?: string;
@@ -2326,6 +2328,7 @@ export async function createAgent(
     description: input.description ?? null,
   };
   if (input.id !== undefined) payload.id = input.id;
+  if (input.title !== undefined) payload.title = input.title;
   if (input.voice !== undefined) payload.voice = input.voice;
   if (input.seed !== undefined) payload.seed = input.seed;
   if (input.model !== undefined) payload.model = input.model;
@@ -2352,6 +2355,7 @@ export async function updateAgent(
   userId: string,
   input: {
     name?: string;
+    title?: string;
     style?: AgentStyle;
     description?: string;
     voice?: string;
@@ -2365,6 +2369,7 @@ export async function updateAgent(
 
   const updatePayload: Record<string, unknown> = { updated_at: new Date().toISOString() };
   if (input.name !== undefined) updatePayload.name = input.name;
+  if (input.title !== undefined) updatePayload.title = input.title;
   if (input.style !== undefined) updatePayload.style = input.style;
   if (input.description !== undefined) updatePayload.description = input.description;
   if (input.voice !== undefined) updatePayload.voice = input.voice;
@@ -2611,7 +2616,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.
+  }
+}

package/cloud-runtime/standalone/lib/history-store.ts

@@ -22,6 +22,8 @@ const REACTION_TYPES = new Set<ReactionType>([
   "clarify",
   "blocked",
 ]);
+const ACTIVE_AGENT_PROCESS_STALE_MS = 10 * 60 * 1000;
+const ACTIVE_CHAT_RUN_STALE_MS = 10 * 60 * 1000;
 const ALLOWED_TRANSITIONS: Record<ReactionType, Set<ReactionType>> = {
   ack: new Set<ReactionType>(["ack", "working"]),
   working: new Set<ReactionType>(["ack", "working", "done", "clarify", "blocked"]),
@@ -223,6 +225,16 @@ function hasSqliteObject(db: Database.Database, type: "table" | "trigger", name:
   return Boolean(row);
 }
 
+function isPidAlive(pid: number | null | undefined): boolean {
+  if (!Number.isFinite(pid) || !pid || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 function initializeMessageSearch(db: Database.Database): void {
   const hasFtsTable = hasSqliteObject(db, "table", "messages_fts");
   db.exec(`
@@ -534,6 +546,11 @@ const withDatabase = async <T>(run: (db: Database.Database) => T): Promise<T> =>
         started_at INTEGER NOT NULL,
         completed_at INTEGER
       );
+      CREATE TABLE IF NOT EXISTS thread_repo_selections (
+        thread_id TEXT NOT NULL,
+        repo_id TEXT NOT NULL,
+        PRIMARY KEY (thread_id, repo_id)
+      );
     `);
     migrateLegacyTables(db);
     migrateThreadReplyColumns(db);
@@ -804,7 +821,7 @@ export async function getProjectThreadIds(projectId: string): Promise<string[]>
   const { getSQLiteDb } = await import("@/lib/sqlite-query-adapter");
   const db = getSQLiteDb();
   const rows = db
-    .prepare("SELECT thread_id FROM project_threads WHERE project_id = ?")
+    .prepare("SELECT thread_id FROM project_threads WHERE project_id = ? ORDER BY created_at ASC")
     .all(projectId) as { thread_id: string }[];
   return rows.map((r) => r.thread_id);
 }
@@ -979,7 +996,7 @@ export async function getThreadStatusSnapshot(
     // These may not have an assistant message yet, so the primary query misses them.
     const activeProcessRows = db
       .prepare(
-        `SELECT ap.agent_id, ap.pid, ap.state, ap.since_message_id, ap.started_at, ap.last_activity,
+        `SELECT ap.id, ap.agent_id, ap.pid, ap.state, ap.since_message_id, ap.started_at, ap.last_activity,
                 m.content as response_to,
                 m.role as response_to_role,
                 m.participant_id as response_to_participant_id
@@ -990,6 +1007,7 @@ export async function getThreadStatusSnapshot(
            AND ap.state IN ('running', 'spawning')`
       )
       .all(scopedRootMessageId) as Array<{
+      id: number;
       agent_id: string;
       pid: number;
       state: string;
@@ -1001,10 +1019,36 @@ export async function getThreadStatusSnapshot(
       response_to_participant_id: string | null;
     }>;
 
+    const now = Date.now();
+    const staleActiveProcessIds = activeProcessRows
+      .filter((ap) => {
+        const lastSeenAt = Math.max(ap.last_activity || 0, ap.started_at || 0);
+        if (lastSeenAt > now - ACTIVE_AGENT_PROCESS_STALE_MS) return false;
+        return !isPidAlive(ap.pid);
+      })
+      .map((ap) => ap.id);
+    const staleActiveProcessIdSet = new Set(staleActiveProcessIds);
+
+    if (staleActiveProcessIds.length > 0) {
+      const markStale = db.prepare(
+        `UPDATE agent_processes
+         SET state = 'error',
+             last_activity = ?
+         WHERE id = ?`
+      );
+      const markManyStale = db.transaction((ids: number[]) => {
+        for (const id of ids) {
+          markStale.run(now, id);
+        }
+      });
+      markManyStale(staleActiveProcessIds);
+    }
+
     // Merge: only add active processes not already represented
     const existingPids = new Set(processes.filter(p => p.processId != null).map(p => p.processId));
     const existingAgents = new Set(processes.filter(p => p.status === "running").map(p => p.agent));
     for (const ap of activeProcessRows) {
+      if (staleActiveProcessIdSet.has(ap.id)) continue;
       if (existingPids.has(ap.pid) || existingAgents.has(ap.agent_id)) continue;
       processes.push({
         processId: ap.pid || null,
@@ -1146,7 +1190,43 @@ export async function createChatRun(input: {
   });
 }
 
+export async function sweepStaleChatRuns(input?: {
+  threadId?: string | null;
+  olderThanMs?: number;
+}): Promise<number> {
+  const normalizedThreadId = normalizeOptionalText(input?.threadId ?? null);
+  const thresholdMs = Number.isFinite(input?.olderThanMs)
+    ? Math.max(input!.olderThanMs!, 1)
+    : ACTIVE_CHAT_RUN_STALE_MS;
+  const now = Date.now();
+  const cutoff = now - thresholdMs;
+
+  return withDatabase((db) => {
+    const clauses = ["status = 'running'", "updated_at <= ?"];
+    const params: Array<string | number> = [cutoff];
+
+    if (normalizedThreadId) {
+      clauses.push("thread_id = ?");
+      params.push(normalizedThreadId);
+    }
+
+    const result = db
+      .prepare(
+        `UPDATE chat_runs
+         SET status = 'failed',
+             last_error = COALESCE(NULLIF(last_error, ''), 'Worker process died mid-execution'),
+             updated_at = ?,
+             completed_at = COALESCE(completed_at, ?)
+         WHERE ${clauses.join(" AND ")}`
+      )
+      .run(now, now, ...params);
+
+    return result.changes;
+  });
+}
+
 export async function getChatRun(chatRunId: string): Promise<ChatRunRecord | null> {
+  await sweepStaleChatRuns();
   return withDatabase((db) => {
     const row = db.prepare("SELECT * FROM chat_runs WHERE id = ? LIMIT 1").get(chatRunId) as ChatRunRow | undefined;
     return row ? toChatRunRecord(row) : null;
@@ -1158,6 +1238,7 @@ export async function listChatRuns(input: {
   status?: ChatRunStatus | "active";
   limit?: number;
 }): Promise<ChatRunRecord[]> {
+  await sweepStaleChatRuns({ threadId: input.threadId });
   const normalizedThreadId = normalizeOptionalText(input.threadId ?? null);
   const limit = clampPositiveInt(input.limit, 20, 100);
   return withDatabase((db) => {
@@ -1803,3 +1884,36 @@ export async function deleteTaskDraft(
       .run(normalizedThreadId, messageId);
   });
 }
+
+// ── Thread repo selections ──────────────────────────────────────────────────
+
+export async function loadThreadRepoSelections(
+  rootMessageId: string,
+): Promise<string[]> {
+  const key = rootMessageId.trim() || LEGACY_THREAD_ID;
+  return withDatabase((db) => {
+    const rows = db
+      .prepare("SELECT repo_id FROM thread_repo_selections WHERE thread_id = ?")
+      .all(key) as Array<{ repo_id: string }>;
+    return rows.map((r) => r.repo_id);
+  });
+}
+
+export async function saveThreadRepoSelections(
+  rootMessageId: string,
+  repoIds: string[],
+): Promise<void> {
+  const key = rootMessageId.trim() || LEGACY_THREAD_ID;
+  return withDatabase((db) => {
+    db.prepare("DELETE FROM thread_repo_selections WHERE thread_id = ?")
+      .run(key);
+    if (repoIds.length > 0) {
+      const insert = db.prepare(
+        "INSERT INTO thread_repo_selections (thread_id, repo_id) VALUES (?, ?)"
+      );
+      for (const repoId of repoIds) {
+        insert.run(key, repoId);
+      }
+    }
+  });
+}