@agentprojectcontext/apx 1.8.2 → 1.10.0

package/src/daemon/api.js

@@ -43,6 +43,12 @@ import { readAgents } from "../core/parser.js";
 import { parseSessionFrontmatter } from "../core/parser.js";
 import { writeAgentFile, ensureAgentDir, regenerateAgentsMd } from "../core/scaffold.js";
 import { buildAgentSystem } from "../core/agent-system.js";
+import {
+  createArtifact,
+  listArtifacts,
+  readArtifact,
+  removeArtifact,
+} from "../core/artifacts-store.js";
 
 const nowIso = () => new Date().toISOString().replace(/\.\d{3}Z$/, "Z");
 
@@ -518,6 +524,35 @@ export function buildApi({ projects, registries, plugins, scheduler, version, st
     }
   });
 
+  // POST /projects/:pid/super-agent/chat
+  app.post("/projects/:pid/super-agent/chat", async (req, res) => {
+    const p = project(req, res);
+    if (!p) return;
+    const { prompt, contextNote, previousMessages, model } = req.body || {};
+    if (!prompt) return res.status(400).json({ error: "prompt required" });
+    try {
+      const saResult = await runSuperAgent({
+        globalConfig: config,
+        projects,
+        plugins,
+        registries,
+        prompt,
+        contextNote: contextNote || `Context: Project ${p.id} (${p.name}) at ${p.path}`,
+        previousMessages: previousMessages || [],
+        overrideModel: model,
+      });
+      projects.rebuild(p.id);
+      res.json({
+        text: saResult.text,
+        usage: saResult.usage,
+        name: saResult.name,
+        trace: saResult.trace,
+      });
+    } catch (e) {
+      res.status(500).json({ error: e.message });
+    }
+  });
+
   // GET /projects/:pid/agents/:slug/conversations
   app.get("/projects/:pid/agents/:slug/conversations", (req, res) => {
     const p = project(req, res);
@@ -739,10 +774,14 @@ export function buildApi({ projects, registries, plugins, scheduler, version, st
     if (!p) return;
     const { id } = req.params;
 
-    const agentsDir = path.join(p.path, ".apc", "agents");
+    const sessionRoots = [
+      path.join(p.storagePath || p.path, "agents"),
+      path.join(p.path, ".apc", "agents"),
+    ];
     let sessionFile = null;
     let agentSlug = null;
-    if (fs.existsSync(agentsDir)) {
+    for (const agentsDir of sessionRoots) {
+      if (!fs.existsSync(agentsDir)) continue;
       for (const slug of fs.readdirSync(agentsDir)) {
         const f = path.join(agentsDir, slug, "sessions", `${id}.md`);
         if (fs.existsSync(f)) {
@@ -751,6 +790,7 @@ export function buildApi({ projects, registries, plugins, scheduler, version, st
           break;
         }
       }
+      if (sessionFile) break;
     }
     if (!sessionFile) return res.status(404).json({ error: `session ${id} not found` });
 
@@ -812,6 +852,7 @@ export function buildApi({ projects, registries, plugins, scheduler, version, st
     const p = project(req, res);
     if (!p) return;
     try {
+      // Pass all fields including pipeline extensions.
       const r = upsertRoutine(p.storagePath, req.body || {});
       res.status(201).json(r);
     } catch (e) {
@@ -819,6 +860,43 @@ export function buildApi({ projects, registries, plugins, scheduler, version, st
     }
   });
 
+  // ---- Artifacts (managed files in storagePath/artifacts/) ---------
+  app.get("/projects/:pid/artifacts", (req, res) => {
+    const p = project(req, res);
+    if (!p) return;
+    res.json(listArtifacts(p.storagePath));
+  });
+
+  app.post("/projects/:pid/artifacts", (req, res) => {
+    const p = project(req, res);
+    if (!p) return;
+    const { name, content = "" } = req.body || {};
+    if (!name) return res.status(400).json({ error: "name required" });
+    try {
+      const filePath = createArtifact(p.storagePath, name, content);
+      res.status(201).json({ name, path: filePath });
+    } catch (e) {
+      res.status(400).json({ error: e.message });
+    }
+  });
+
+  app.get("/projects/:pid/artifacts/:name", (req, res) => {
+    const p = project(req, res);
+    if (!p) return;
+    try {
+      res.json(readArtifact(p.storagePath, decodeURIComponent(req.params.name)));
+    } catch (e) {
+      res.status(404).json({ error: e.message });
+    }
+  });
+
+  app.delete("/projects/:pid/artifacts/:name", (req, res) => {
+    const p = project(req, res);
+    if (!p) return;
+    const ok = removeArtifact(p.storagePath, decodeURIComponent(req.params.name));
+    res.status(ok ? 204 : 404).end();
+  });
+
   app.delete("/projects/:pid/routines/:name", (req, res) => {
     const p = project(req, res);
     if (!p) return;

package/src/daemon/env-detect.js

@@ -11,6 +11,7 @@ const PROBES = [
   { id: "aider",       binary: "aider",     args: ["--version"], category: "runtime" },
   { id: "gemini-cli",  binary: "gemini",    args: ["--version"], category: "runtime" },
   { id: "cursor-agent",binary: "cursor-agent", args: ["--version"], category: "runtime" },
+  { id: "qwen-code",   binary: "qwen",      args: ["--version"], category: "runtime" },
 
   // Local LLM runners (engines/)
   { id: "ollama",      binary: "ollama",    args: ["--version"], category: "engine" },

package/src/daemon/routines.js

@@ -11,10 +11,15 @@
 //   shell       — run a shell command.        spec: { command, timeout_ms? }
 
 import { spawn } from "node:child_process";
+import { execFile } from "node:child_process";
+import os from "node:os";
+import fs from "node:fs";
+import path from "node:path";
 import { callEngine } from "./engines/index.js";
 import { runSuperAgent } from "./super-agent.js";
 import { readAgents } from "../core/parser.js";
 import { buildAgentSystem } from "../core/agent-system.js";
+import { resolveArtifactRef, ARTIFACTS_SKIP_SIGNAL } from "../core/artifacts-store.js";
 import {
   listRoutines,
   getRoutine,
@@ -169,25 +174,148 @@ const HANDLERS = {
   shell: handleShell,
 };
 
+// --------------------- pipeline: pre/post shell commands --------------------
+
+// Run a single shell command. Returns { exitCode, stdout, stderr }.
+function runShellCmd(cmd, env = {}, cwd = os.homedir()) {
+  return new Promise((resolve) => {
+    const child = spawn("sh", ["-c", cmd], {
+      cwd,
+      env: { ...process.env, ...env },
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (c) => (stdout += c.toString()));
+    child.stderr.on("data", (c) => (stderr += c.toString()));
+    child.on("close", (code) => resolve({ exitCode: code ?? 0, stdout, stderr }));
+    child.on("error", (e) => resolve({ exitCode: 1, stdout: "", stderr: e.message }));
+  });
+}
+
+// Inject {{pre_output}} into a prompt string.
+function injectPreOutput(prompt, preOutput) {
+  if (!prompt || typeof prompt !== "string") return prompt;
+  return prompt.replace(/\{\{pre_output\}\}/g, preOutput || "");
+}
+
+// Determine whether to skip the LLM call based on skip_prompt_on + pre results.
+function shouldSkipPrompt(routine, preExitCode, preStdout) {
+  const mode = routine.skip_prompt_on || "signal";
+  if (mode === "always") return true;
+  if (mode === "never") return false;
+  if (mode === "signal") return preStdout.includes(ARTIFACTS_SKIP_SIGNAL);
+  if (mode === "pre_failure") return preExitCode !== 0;
+  if (mode === "pre_success") return preExitCode === 0;
+  return false;
+}
+
 // --------------------- runtime: run one + loop ------------------------------
 
 export async function runRoutineNow(ctx, routine) {
-  const handler = HANDLERS[routine.kind];
-  if (!handler) throw new Error(`unknown routine kind: ${routine.kind}`);
-  let result;
+  // Determine the working directory for shell commands.
+  const cwd = ctx.project?.path || os.homedir();
+  const storagePath = ctx.project?.storagePath || os.homedir();
+
+  const hasPreCmds  = Array.isArray(routine.pre_commands)  && routine.pre_commands.length  > 0;
+  const hasPostCmds = Array.isArray(routine.post_commands) && routine.post_commands.length > 0;
+
+  let preStdout = "";
+  let preExitCode = 0;
+  let preOutputFile = null;
+
+  // ── Phase 1: pre_commands ──────────────────────────────────────────────────
+  if (hasPreCmds) {
+    const combinedOut = [];
+    for (const rawCmd of routine.pre_commands) {
+      // Resolve "artifact:<name>" shorthand to its absolute path.
+      const cmd = resolveArtifactRef(rawCmd, storagePath);
+      const { exitCode, stdout, stderr } = await runShellCmd(cmd, {}, cwd);
+      combinedOut.push(stdout);
+      if (stderr) combinedOut.push(stderr);
+      preExitCode = exitCode;
+      if (exitCode !== 0 && (routine.skip_prompt_on === "pre_failure" || routine.skip_prompt_on === "signal")) {
+        // Stop running further pre_commands on failure when mode cares about exit code.
+        break;
+      }
+    }
+    preStdout = combinedOut.join("");
+
+    // Write pre output to a temp file so post_commands can reference it via
+    // $APX_PRE_OUTPUT_FILE even if the output is large.
+    try {
+      preOutputFile = path.join(os.tmpdir(), `apx-pre-${routine.name}-${Date.now()}.txt`);
+      fs.writeFileSync(preOutputFile, preStdout);
+    } catch { preOutputFile = null; }
+  }
+
+  // Env vars injected into post_commands and available in shell pre_commands output.
+  const pipelineEnv = {
+    APX_PRE_EXIT: String(preExitCode),
+    APX_PRE_OUTPUT: preStdout.slice(0, 32_000), // guard against huge outputs
+    APX_PRE_OUTPUT_FILE: preOutputFile || "",
+    APX_ROUTINE: routine.name,
+  };
+
+  // ── Phase 2: LLM / handler ────────────────────────────────────────────────
+  const skip = hasPreCmds && shouldSkipPrompt(routine, preExitCode, preStdout);
+
+  let result = { status: "ok" };
   let status = "ok";
   let errMsg = null;
-  try {
-    result = await handler(ctx, routine);
-    if (result?.status === "error") {
+
+  if (!skip) {
+    // Inject {{pre_output}} into exec_agent and super_agent prompts.
+    const enrichedRoutine = (hasPreCmds && preStdout)
+      ? {
+          ...routine,
+          spec: {
+            ...routine.spec,
+            prompt: injectPreOutput(routine.spec?.prompt, preStdout),
+          },
+        }
+      : routine;
+
+    const handler = HANDLERS[enrichedRoutine.kind];
+    if (!handler) {
       status = "error";
-      errMsg = result.error || result.stderr || `routine ${routine.name} returned error status`;
+      errMsg = `unknown routine kind: ${enrichedRoutine.kind}`;
+    } else {
+      try {
+        result = await handler(ctx, enrichedRoutine);
+        if (result?.status === "error") {
+          status = "error";
+          errMsg = result.error || result.stderr || `routine ${routine.name} returned error status`;
+        }
+      } catch (e) {
+        status = "error";
+        errMsg = e.message;
+        result = { status: "error", error: e.message };
+      }
     }
-  } catch (e) {
-    status = "error";
-    errMsg = e.message;
-    result = { status: "error", error: e.message };
+  } else {
+    result = { status: "ok", skipped: true, note: "pre_commands signalled skip" };
   }
+
+  // ── Phase 3: post_commands ────────────────────────────────────────────────
+  if (hasPostCmds) {
+    const llmOutput = result?.reply || result?.text || "";
+    const postEnv = {
+      ...pipelineEnv,
+      APX_LLM_OUTPUT: llmOutput.slice(0, 32_000),
+      APX_STATUS: status,
+      APX_SKIPPED: skip ? "1" : "0",
+    };
+    for (const rawCmd of routine.post_commands) {
+      const cmd = resolveArtifactRef(rawCmd, storagePath);
+      await runShellCmd(cmd, postEnv, cwd);
+      // Post-command failures are logged but don't change routine status.
+    }
+  }
+
+  // Cleanup temp file.
+  if (preOutputFile) try { fs.unlinkSync(preOutputFile); } catch {}
+
   const lastRun = nowIso();
   const next = computeNextRun({ schedule: routine.schedule, last_run_at: lastRun });
   const isOnce = parseSchedule(routine.schedule).kind === "once";
@@ -205,9 +333,9 @@ export async function runRoutineNow(ctx, routine) {
     actor_id: "apx:routine",
     author: "apx",
     body: status === "ok"
-      ? `routine ${routine.name} ok`
+      ? `routine ${routine.name} ok${skip ? " (skipped LLM)" : ""}`
       : `routine ${routine.name} error: ${errMsg}`,
-    meta: { routine: routine.name, status, result },
+    meta: { routine: routine.name, status, skipped: skip, result },
   });
   return { ...result, last_run_at: lastRun, next_run_at: next };
 }

package/src/daemon/runtimes/claude-code.js

@@ -3,8 +3,31 @@
 // Returns one JSON line with the result and session_id.
 // Reference: https://docs.claude.com/en/docs/claude-code/headless
 
+import fs from "node:fs";
+import path from "node:path";
 import { runProcess } from "./_spawn.js";
 
+export function encodeClaudeProjectPath(cwd) {
+  return String(cwd || process.cwd()).replace(/[^A-Za-z0-9]/g, "-");
+}
+
+export function resolveClaudeSessionPath({ cwd, sessionId, home = process.env.HOME || process.env.USERPROFILE || "" }) {
+  if (!sessionId || !home) return null;
+  const projectsDir = path.join(home, ".claude", "projects");
+  const encodedCwd = encodeClaudeProjectPath(cwd);
+  const expected = path.join(projectsDir, encodedCwd, `${sessionId}.jsonl`);
+  if (fs.existsSync(expected)) return expected;
+
+  try {
+    for (const dir of fs.readdirSync(projectsDir)) {
+      const candidate = path.join(projectsDir, dir, `${sessionId}.jsonl`);
+      if (fs.existsSync(candidate)) return candidate;
+    }
+  } catch {}
+
+  return expected;
+}
+
 export default {
   id: "claude-code",
   binary: "claude",
@@ -40,12 +63,7 @@ export default {
     }
 
     if (sessionId) {
-      // Claude Code's session directory naming: replace BOTH "/" and "_" with
-      // "-" (verified empirically against ~/.claude/projects/). The trailing
-      // file is `<sessionId>.jsonl`.
-      const home = process.env.HOME || process.env.USERPROFILE || "";
-      const encodedCwd = (cwd || process.cwd()).replace(/[/_]/g, "-");
-      externalSessionPath = `${home}/.claude/projects/${encodedCwd}/${sessionId}.jsonl`;
+      externalSessionPath = resolveClaudeSessionPath({ cwd, sessionId });
     }
 
     return {

package/src/daemon/runtimes/cursor-agent.js

@@ -0,0 +1,34 @@
+// Cursor Agent runtime adapter. Uses print mode for non-interactive runs:
+//   cursor-agent --print --output-format text --trust --force "<prompt>"
+// Reference: https://docs.cursor.com/en/cli/headless
+
+import { runProcess } from "./_spawn.js";
+
+export default {
+  id: "cursor-agent",
+  binary: "cursor-agent",
+  versionFlag: "--version",
+
+  async run({ system, prompt, cwd, env, timeoutMs }) {
+    const fullPrompt = system ? `${system}\n\n---\n\n${prompt}` : prompt;
+    const r = await runProcess({
+      command: "cursor-agent",
+      args: [
+        "--print",
+        "--output-format", "text",
+        "--trust",
+        "--force",
+        fullPrompt,
+      ],
+      cwd,
+      env,
+      timeoutMs,
+    });
+    return {
+      exitCode: r.exitCode,
+      output: r.stdout.trim(),
+      stderr: r.stderr,
+      externalSessionPath: null,
+    };
+  },
+};

package/src/daemon/runtimes/gemini-cli.js

@@ -0,0 +1,32 @@
+// Gemini CLI runtime adapter. Uses headless prompt mode:
+//   gemini --prompt "<prompt>" --output-format text --approval-mode yolo
+// Reference: https://google-gemini.github.io/gemini-cli/docs/cli/headless.html
+
+import { runProcess } from "./_spawn.js";
+
+export default {
+  id: "gemini-cli",
+  binary: "gemini",
+  versionFlag: "--version",
+
+  async run({ system, prompt, cwd, env, timeoutMs }) {
+    const fullPrompt = system ? `${system}\n\n---\n\n${prompt}` : prompt;
+    const r = await runProcess({
+      command: "gemini",
+      args: [
+        "--prompt", fullPrompt,
+        "--output-format", "text",
+        "--approval-mode", "yolo",
+      ],
+      cwd,
+      env,
+      timeoutMs,
+    });
+    return {
+      exitCode: r.exitCode,
+      output: r.stdout.trim(),
+      stderr: r.stderr,
+      externalSessionPath: null,
+    };
+  },
+};

package/src/daemon/runtimes/index.js

@@ -1,5 +1,6 @@
 // Runtime adapters: spawn external agent CLIs (Claude Code, Codex, OpenCode,
-// Aider, ...) with the agent's system prompt + the prompt we want to run, and
+// Aider, Cursor Agent, Gemini CLI, Qwen Code, ...) with the agent's system
+// prompt + the prompt we want to run, and
 // capture their output. Unlike engines/ — which talk directly to model APIs —
 // runtimes/ delegate the whole conversation to the external tool. APX only
 // records the invocation, the prompt, the captured output, and where the tool
@@ -18,12 +19,18 @@ import claudeCode from "./claude-code.js";
 import codex from "./codex.js";
 import opencode from "./opencode.js";
 import aider from "./aider.js";
+import cursorAgent from "./cursor-agent.js";
+import geminiCli from "./gemini-cli.js";
+import qwenCode from "./qwen-code.js";
 
 const REGISTRY = {
   "claude-code": claudeCode,
   codex,
   opencode,
   aider,
+  "cursor-agent": cursorAgent,
+  "gemini-cli": geminiCli,
+  "qwen-code": qwenCode,
 };
 
 export const RUNTIME_IDS = Object.keys(REGISTRY);

package/src/daemon/runtimes/qwen-code.js

@@ -0,0 +1,36 @@
+// Qwen Code runtime adapter. Uses non-interactive mode:
+//   qwen --output-format text --approval-mode yolo "<prompt>"
+// Reference: https://qwenlm.github.io/qwen-code-docs/en/cli/index
+
+import { runProcess } from "./_spawn.js";
+
+export default {
+  id: "qwen-code",
+  binary: "qwen",
+  versionFlag: "--version",
+
+  async run({ system, prompt, cwd, env, timeoutMs }) {
+    const args = [
+      "--output-format", "text",
+      "--approval-mode", "yolo",
+    ];
+    if (system) {
+      args.push("--append-system-prompt", system);
+    }
+    args.push(prompt);
+
+    const r = await runProcess({
+      command: "qwen",
+      args,
+      cwd,
+      env,
+      timeoutMs,
+    });
+    return {
+      exitCode: r.exitCode,
+      output: r.stdout.trim(),
+      stderr: r.stderr,
+      externalSessionPath: null,
+    };
+  },
+};

package/src/daemon/super-agent-tools/index.js

@@ -18,6 +18,7 @@ import callRuntime from "./tools/call-runtime.js";
 import sendTelegram from "./tools/send-telegram.js";
 import setIdentity from "./tools/set-identity.js";
 import setPermissionMode from "./tools/set-permission-mode.js";
+import searchFiles from "./tools/search-files.js";
 import { createPermissionGuard } from "./helpers.js";
 
 const TOOLS = [
@@ -41,6 +42,7 @@ const TOOLS = [
   sendTelegram,
   setIdentity,
   setPermissionMode,
+  searchFiles,
 ];
 
 export const TOOL_SCHEMAS = TOOLS.map((tool) => tool.schema);