@agentprojectcontext/apx 1.65.3 → 1.67.0

package/src/core/stores/conversations-compactor.js

@@ -25,30 +25,22 @@
 import fs from "node:fs";
 import path from "node:path";
 import { parseConversation } from "./conversations.js";
-import { callEngine } from "#core/engines/index.js";
+import {
+  renderEvents,
+  buildCondenserPrompt,
+  summarizeStructured,
+} from "#core/memory/summarizer.js";
 
 const KEEP_LAST = 6;
 
 const nowIso = () => new Date().toISOString().replace(/\.\d{3}Z$/, "Z");
 
-const COMPACT_SYSTEM =
-  "You summarize conversations for AI agent context continuity. " +
-  "Be dense and factual — another AI will read this to continue the work.";
-
-const COMPACT_PROMPT = `Summarize this conversation for future context.
-
-Cover:
-- Main task or goal being worked on
-- Key decisions made and why
-- Files, code, commands modified (exact paths where relevant)
-- Current state: what's done, what's pending or unresolved
-- Errors encountered and how they were resolved
-
-Style: dense and factual. No pleasantries. No meta-commentary. Just the facts.
-
----
-
-`;
+// Map a parsed conversation role to the summarizer's normalized event role.
+function toEventRole(role) {
+  if (role === "user") return "user";
+  if (role === "tool") return "tool";
+  return "assistant"; // assistant / system → assistant side
+}
 
 // Resolve the most-recent conversation file for an agent, or the one explicitly
 // named. Returns the full filepath.
@@ -90,19 +82,21 @@ export async function compactConversation({
   const realTurns = turns.filter((t) => t.role !== "compact");
   if (realTurns.length === 0) throw new Error("nothing to compact — no user/assistant turns");
 
-  // Build a readable transcript for the model.
-  const transcript = realTurns
-    .map((t) => `[${t.role.toUpperCase()}]\n${t.content}`)
-    .join("\n\n---\n\n");
-
-  const result = await callEngine({
-    modelId,
-    system: COMPACT_SYSTEM,
-    messages: [{ role: "user", content: COMPACT_PROMPT + transcript }],
+  // Same summarizer service as the automatic condenser (structured state),
+  // just a different store/entry point. The whole conversation is condensed
+  // (no previous-summary threading here — a fresh compact per call).
+  const eventsBlock = renderEvents(
+    realTurns.map((t) => ({ role: toEventRole(t.role), content: t.content }))
+  );
+  const prompt = buildCondenserPrompt({ eventsBlock });
+  const out = await summarizeStructured({
+    prompt,
+    models: { primary: modelId, fallback: config?.super_agent?.model || "" },
     config,
   });
+  if (!out) throw new Error("compaction failed — no model produced a summary");
 
-  const summary = result.text.trim();
+  const summary = out.text;
   const ts = nowIso();
   const turnCount = realTurns.length;
 
@@ -133,8 +127,7 @@ export async function compactConversation({
     filename: path.basename(filepath),
     compacted_turns: turnCount,
     kept_turns: recentTurns.length,
-    model: modelId,
+    model: out.model,
     summary,
-    usage: result.usage,
   };
 }

package/src/host/daemon/api/admin-config.js

@@ -14,6 +14,7 @@ import {
   isSecretMarker,
   mergeRedactedChannels,
 } from "#core/config/redact.js";
+import { collectSecretValues, registerSecretValues } from "#core/config/secret-values.js";
 
 export function register(app, { config, scheduler, plugins }) {
   app.get("/admin/config", (_req, res) => {
@@ -57,6 +58,10 @@ export function register(app, { config, scheduler, plugins }) {
     const fresh = readConfig();
     for (const key of Object.keys(config)) delete config[key];
     Object.assign(config, fresh);
+    // Keep the log-masking registry current: any secret just added via PATCH
+    // must be masked from this point on (registry is additive — removed
+    // secrets stay masked, which is the safe direction).
+    registerSecretValues(collectSecretValues(fresh));
     if (scheduler) scheduler.globalConfig = config;
     if (plugins) plugins.config = config;
     res.json({ ok: true, config: redact(fresh) });

package/src/host/daemon/api/artifact-preview.js

@@ -0,0 +1,82 @@
+// Artifact preview + sharing routes.
+//   POST   /projects/:pid/artifacts/:name/preview   body: { watch? }
+//   GET    /projects/:pid/previews
+//   GET    /previews
+//   DELETE /previews/:id
+//   POST   /previews/:id/tunnel                      body: { provider? }
+//   DELETE /previews/:id/tunnel
+//
+// Preview servers and tunnels live in process-wide singletons (see
+// #core/artifacts/preview.js and tunnel.js) so they survive across requests
+// for the daemon's lifetime.
+import { previews } from "#core/artifacts/preview.js";
+import { tunnels, detectProviders } from "#core/artifacts/tunnel.js";
+
+export function register(app, { project }) {
+  // Start (or reuse) an ephemeral preview server for an artifact.
+  app.post("/projects/:pid/artifacts/:name/preview", async (req, res) => {
+    const p = project(req, res);
+    if (!p) return;
+    const name = decodeURIComponent(req.params.name);
+    const watch = req.body?.watch !== false;
+    try {
+      const view = await previews.start({
+        storagePath: p.storagePath,
+        name,
+        projectId: p.id,
+        watch,
+      });
+      res.status(201).json(view);
+    } catch (e) {
+      res.status(400).json({ error: e.message });
+    }
+  });
+
+  // List preview servers scoped to a project.
+  app.get("/projects/:pid/previews", (req, res) => {
+    const p = project(req, res);
+    if (!p) return;
+    res.json(previews.list(p.id));
+  });
+
+  // List every live preview (all projects).
+  app.get("/previews", (_req, res) => {
+    res.json(previews.list());
+  });
+
+  // Which tunnel providers this host can use, best first.
+  app.get("/previews/tunnel-providers", (_req, res) => {
+    res.json({ providers: detectProviders() });
+  });
+
+  // Stop a preview server (also closes its tunnel).
+  app.delete("/previews/:id", async (req, res) => {
+    const rec = previews.get(req.params.id);
+    if (rec?.tunnel) tunnels.close(rec.tunnel.id);
+    const ok = await previews.stop(req.params.id);
+    res.status(ok ? 204 : 404).end();
+  });
+
+  // Open a public tunnel to a preview's local port.
+  app.post("/previews/:id/tunnel", async (req, res) => {
+    const rec = previews.get(req.params.id);
+    if (!rec) return res.status(404).json({ error: "preview not found" });
+    if (rec.tunnel) return res.json(rec.tunnel); // already shared
+    try {
+      const tunnel = await tunnels.open(rec.port, { provider: req.body?.provider });
+      previews.attachTunnel(rec.id, tunnel);
+      res.status(201).json(tunnel);
+    } catch (e) {
+      res.status(502).json({ error: e.message });
+    }
+  });
+
+  // Close a preview's tunnel but keep the local server running.
+  app.delete("/previews/:id/tunnel", (req, res) => {
+    const rec = previews.get(req.params.id);
+    if (!rec || !rec.tunnel) return res.status(404).end();
+    tunnels.close(rec.tunnel.id);
+    previews.attachTunnel(rec.id, null);
+    res.status(204).end();
+  });
+}

package/src/host/daemon/api/engines.js

@@ -1,12 +1,18 @@
 // GET  /engines            — list engine adapter ids known to core/engines.
+// GET  /engines/presets     — curated catalog (known models, defaults) per engine.
 // POST /engines/models      — live model catalog from a provider.
 // GET  /engines/models      — legacy (Ollama only, no auth).
 import { ENGINE_IDS } from "#core/engines/index.js";
 import { listModels } from "#core/engines/catalog.js";
+import { ENGINE_PRESETS } from "#core/engines/presets.js";
 
 export function register(app, { config }) {
   app.get("/engines", (_req, res) => res.json({ engines: ENGINE_IDS }));
 
+  // Curated fallback catalog shared with the CLI wizard. The web hydrates its
+  // provider forms from here so model lists never drift between surfaces.
+  app.get("/engines/presets", (_req, res) => res.json({ presets: ENGINE_PRESETS }));
+
   app.post("/engines/models", async (req, res) => {
     const b = req.body || {};
     const engine = String(b.engine || "").toLowerCase();

package/src/host/daemon/api/web.js

@@ -24,7 +24,7 @@ const API_PREFIXES = [
   "/health", "/admin", "/projects", "/telegram", "/engines", "/runtimes",
   "/messages", "/sessions", "/tools", "/mcp", "/voice", "/tts", "/desktop", "/overlay",
   "/transcribe", "/run", "/files", "/memory", "/env", "/pair", "/deck",
-  "/super-agent", "/identity",
+  "/super-agent", "/identity", "/skills",
 ];
 
 export function isApiPath(p) {

package/src/host/daemon/api.js

@@ -33,6 +33,7 @@ import { register as registerConnections } from "./api/connections.js";
 import { register as registerRuntimes } from "./api/runtimes.js";
 import { register as registerRoutines } from "./api/routines.js";
 import { register as registerArtifacts } from "./api/artifacts.js";
+import { register as registerArtifactPreview } from "./api/artifact-preview.js";
 import { register as registerTasks } from "./api/tasks.js";
 import { register as registerOrganization } from "./api/organization.js";
 import { register as registerProjectFiles } from "./api/files-project.js";
@@ -124,6 +125,7 @@ export function buildApi({
   registerRuntimes(app, ctx);
   registerRoutines(app, ctx);
   registerArtifacts(app, ctx);
+  registerArtifactPreview(app, ctx);
   registerTasks(app, ctx);
   registerOrganization(app, ctx);
   registerProjectFiles(app, ctx);

package/src/host/daemon/index.js

@@ -15,6 +15,12 @@ import {
   APX_HOME,
   TOKEN_PATH,
 } from "#core/config/index.js";
+import {
+  collectSecretValues,
+  collectMcpSecretValues,
+  registerSecretValues,
+} from "#core/config/secret-values.js";
+import { readGlobalMcps, readRuntimeMcps } from "#core/mcp/sources.js";
 import { ProjectManager } from "./db.js";
 import { McpRegistry } from "#core/mcp/runner.js";
 import { PluginManager } from "./plugins/index.js";
@@ -156,17 +162,26 @@ async function main() {
   const host = effectiveHost(cfg);
   const port = effectivePort(cfg);
 
+  // Value-based secret masking: register every known secret VALUE (engine
+  // keys, telegram tokens, MCP env/header tokens) so core/logging.js can
+  // scrub them from any log text they leak into. Refreshed on config PATCH
+  // in api/admin-config.js.
+  registerSecretValues(collectSecretValues(cfg));
+  registerSecretValues(collectMcpSecretValues(readGlobalMcps()));
+
   const projects = new ProjectManager(cfg);
   const registries = new RegistryCache();
 
   // Default project (id=0) is always available — no local .apc/ required.
-  projects.registerDefault();
+  const defaultProject = projects.registerDefault();
+  registerSecretValues(collectMcpSecretValues(readRuntimeMcps(defaultProject.storagePath)));
 
   // Load registered projects from config.
   for (const entry of cfg.projects) {
     try {
       const p = projects.register(entry.path);
       registries.ensure(p);
+      registerSecretValues(collectMcpSecretValues(readRuntimeMcps(p.storagePath)));
       log(`loaded project #${p.id} ${p.path}`);
     } catch (e) {
       log(`skipping project ${entry.path}: ${e.message}`);

package/src/interfaces/acp/index.js

@@ -0,0 +1,363 @@
+#!/usr/bin/env node
+// APX ACP agent — serves the APX super-agent over the Agent Client Protocol
+// (https://agentclientprotocol.com, JSON-RPC 2.0 over newline-delimited JSON
+// on stdio), so ACP clients (Zed, JetBrains, marimo, …) can drive it.
+// Canonical launch: `apx acp` (bin alias `apx-acp` mirrors `apx-mcp`).
+//
+// Like the mcp-server surface, this is a thin adapter over the daemon HTTP
+// API: each `session/prompt` becomes a POST to the NDJSON stream endpoint
+// `/projects/:pid/super-agent/chat/stream` and the stream events are mapped
+// onto ACP `session/update` notifications:
+//
+//   assistant_text         → agent_message_chunk
+//   tool_start             → tool_call        (status: in_progress)
+//   tool_result            → tool_call_update (status: completed|failed)
+//   confirmation_required  → session/request_permission round-trip, answered
+//                            via POST /super-agent/confirm/:correlationId
+//   final                  → session/prompt response { stopReason }
+//
+// IMPORTANT: stdout carries the protocol. Never log to stdout here — errors
+// go to stderr and the unified file log only.
+
+import fs from "node:fs";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { CHANNELS } from "#core/constants/channels.js";
+import { loggerFor } from "#core/logging.js";
+import { APX_HOME } from "#core/config/index.js";
+import { JsonRpcConnection, JsonRpcError, JSONRPC_ERROR_CODES } from "./jsonrpc.js";
+import {
+  createDaemonClient,
+  createSession,
+  extractPromptText,
+  resolveProjectForCwd,
+  summarizeToolResult,
+  toolKindFor,
+} from "./session.js";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+// Single major version integer per the ACP initialization spec.
+export const ACP_PROTOCOL_VERSION = 1;
+
+const log = loggerFor("acp");
+
+function packageVersion() {
+  try {
+    return JSON.parse(
+      fs.readFileSync(path.join(__dirname, "..", "..", "..", "package.json"), "utf8")
+    ).version;
+  } catch {
+    return "0.0.0";
+  }
+}
+
+export class AcpAgentServer {
+  /**
+   * @param {{ input: import("node:stream").Readable,
+   *           output: import("node:stream").Writable,
+   *           daemon: { baseUrl: string, token?: string | (() => string) },
+   *           ensureDaemon?: (() => Promise<void>) | null,
+   *           version?: string }} opts
+   * `daemon` and the streams are injectable so tests can run fully offline
+   * against an in-process daemon API and PassThrough pipes.
+   */
+  constructor({ input, output, daemon, ensureDaemon = null, version = packageVersion() }) {
+    this.version = version;
+    this.sessions = new Map();
+    this.clientCapabilities = {};
+    this.client = createDaemonClient({
+      baseUrl: daemon.baseUrl,
+      token: daemon.token || "",
+      ensureReady: ensureDaemon,
+    });
+    this.connection = new JsonRpcConnection({
+      input,
+      output,
+      onError: (e) => this.#logError("connection error", e),
+    });
+  }
+
+  start() {
+    this.connection
+      .method("initialize", (params) => this.#initialize(params))
+      // No auth methods are advertised, so authenticate is a no-op accept —
+      // daemon access control is the local bearer token, not an ACP concern.
+      .method("authenticate", () => ({}))
+      .method("session/new", (params) => this.#newSession(params))
+      .method("session/prompt", (params) => this.#prompt(params))
+      .method("session/cancel", (params) => this.#cancel(params));
+    return this;
+  }
+
+  whenClosed() {
+    return this.connection.whenClosed();
+  }
+
+  #logError(msg, err) {
+    const detail = err?.message || String(err || "");
+    try {
+      log.error(`${msg}: ${detail}`);
+    } catch {
+      /* file log is best-effort */
+    }
+    process.stderr.write(`apx acp: ${msg}: ${detail}\n`);
+  }
+
+  #initialize(params) {
+    const requested = Number(params?.protocolVersion);
+    this.clientCapabilities = params?.clientCapabilities || {};
+    return {
+      // Same version when we support what the client asked for, otherwise the
+      // latest we do support — the client decides whether to disconnect.
+      protocolVersion:
+        requested === ACP_PROTOCOL_VERSION ? requested : ACP_PROTOCOL_VERSION,
+      agentCapabilities: {
+        loadSession: false,
+        promptCapabilities: { image: false, audio: false, embeddedContext: false },
+        mcpCapabilities: { http: false, sse: false },
+      },
+      agentInfo: { name: "apx", title: "APX Super-Agent", version: this.version },
+      authMethods: [],
+    };
+  }
+
+  async #newSession(params) {
+    const cwd = params?.cwd;
+    if (!cwd || typeof cwd !== "string" || !path.isAbsolute(cwd)) {
+      throw new JsonRpcError(
+        JSONRPC_ERROR_CODES.INVALID_PARAMS,
+        "cwd must be an absolute path"
+      );
+    }
+    let project;
+    try {
+      project = await resolveProjectForCwd(this.client, cwd);
+    } catch (e) {
+      throw new JsonRpcError(JSONRPC_ERROR_CODES.INTERNAL_ERROR, e.message);
+    }
+    const sessionId = `sess_${randomUUID().replace(/-/g, "")}`;
+    this.sessions.set(sessionId, createSession({ id: sessionId, project, cwd }));
+    return { sessionId };
+  }
+
+  #session(params) {
+    const session = this.sessions.get(params?.sessionId);
+    if (!session) {
+      throw new JsonRpcError(
+        JSONRPC_ERROR_CODES.INVALID_PARAMS,
+        `unknown sessionId: ${params?.sessionId}`
+      );
+    }
+    return session;
+  }
+
+  async #prompt(params) {
+    const session = this.#session(params);
+    if (session.activeTurn) {
+      throw new JsonRpcError(
+        JSONRPC_ERROR_CODES.INVALID_REQUEST,
+        "a prompt turn is already in progress for this session"
+      );
+    }
+    const promptText = extractPromptText(params.prompt);
+    if (!promptText) {
+      throw new JsonRpcError(
+        JSONRPC_ERROR_CODES.INVALID_PARAMS,
+        "prompt must include at least one text content block"
+      );
+    }
+
+    const turn = {
+      abort: new AbortController(),
+      cancelled: false,
+      lastToolCallId: null,
+      messageSeq: 0,
+      sentTexts: new Set(),
+    };
+    session.activeTurn = turn;
+    try {
+      const final = await this.client.streamPost(
+        `/projects/${session.project.id}/super-agent/chat/stream`,
+        {
+          prompt: promptText,
+          // ACP clients are coding surfaces (IDEs) — the `code` channel gives
+          // them the coding system prompt + git/code tools, same as apx code.
+          channel: CHANNELS.CODE,
+          previousMessages: session.history,
+        },
+        (event) => this.#onDaemonEvent(session, turn, event),
+        { signal: turn.abort.signal }
+      );
+      if (turn.cancelled) return { stopReason: "cancelled" };
+      if (!final) {
+        throw new JsonRpcError(
+          JSONRPC_ERROR_CODES.INTERNAL_ERROR,
+          "daemon stream ended without a final result"
+        );
+      }
+      // In-process history feeds previousMessages on the next turn, so the
+      // conversation keeps context without daemon-side session storage.
+      session.history.push({ role: "user", content: promptText });
+      if (final.text) session.history.push({ role: "assistant", content: final.text });
+      return { stopReason: "end_turn" };
+    } catch (e) {
+      // Aborts surface as generic stream errors — per spec, cancellation MUST
+      // resolve the prompt with the "cancelled" stop reason, never an error.
+      if (turn.cancelled) return { stopReason: "cancelled" };
+      if (e instanceof JsonRpcError) throw e;
+      throw new JsonRpcError(JSONRPC_ERROR_CODES.INTERNAL_ERROR, e.message);
+    } finally {
+      session.activeTurn = null;
+    }
+  }
+
+  // session/cancel is a notification — no response, just abort the in-flight
+  // daemon stream; #prompt observes `cancelled` and resolves the turn.
+  #cancel(params) {
+    const session = this.sessions.get(params?.sessionId);
+    const turn = session?.activeTurn;
+    if (!turn) return;
+    turn.cancelled = true;
+    turn.abort.abort();
+  }
+
+  #notifyUpdate(session, update) {
+    this.connection.notify("session/update", { sessionId: session.id, update });
+  }
+
+  #sendMessageChunk(session, turn, text) {
+    const value = String(text || "");
+    if (!value || turn.sentTexts.has(value)) return;
+    turn.sentTexts.add(value);
+    turn.messageSeq += 1;
+    this.#notifyUpdate(session, {
+      sessionUpdate: "agent_message_chunk",
+      messageId: `msg_${session.seq}_${turn.messageSeq}`,
+      content: { type: "text", text: value },
+    });
+  }
+
+  async #onDaemonEvent(session, turn, event) {
+    switch (event?.type) {
+      case "assistant_text":
+        return this.#sendMessageChunk(session, turn, event.text);
+      // The loop only emits assistant_text for mid-turn progress; the closing
+      // reply usually travels solely inside the final result, so surface it
+      // as a chunk here (deduped against anything already streamed).
+      case "final":
+        return this.#sendMessageChunk(session, turn, event.result?.text);
+      case "tool_start": {
+        const trace = event.trace || {};
+        const toolCallId = String(trace.id || `call_${randomUUID().slice(0, 8)}`);
+        turn.lastToolCallId = toolCallId;
+        this.#notifyUpdate(session, {
+          sessionUpdate: "tool_call",
+          toolCallId,
+          title: String(trace.tool || "tool"),
+          kind: toolKindFor(trace.tool),
+          status: "in_progress",
+          ...(trace.args && typeof trace.args === "object" ? { rawInput: trace.args } : {}),
+        });
+        return;
+      }
+      case "tool_result": {
+        const trace = event.trace || {};
+        const failed =
+          trace.result && typeof trace.result === "object" && trace.result.error != null;
+        this.#notifyUpdate(session, {
+          sessionUpdate: "tool_call_update",
+          toolCallId: String(trace.id || turn.lastToolCallId || "call_unknown"),
+          status: failed ? "failed" : "completed",
+          content: [
+            {
+              type: "content",
+              content: { type: "text", text: summarizeToolResult(trace.result) },
+            },
+          ],
+          ...(trace.result && typeof trace.result === "object"
+            ? { rawOutput: trace.result }
+            : {}),
+        });
+        return;
+      }
+      case "confirmation_required":
+        return this.#requestPermission(session, turn, event);
+      default:
+        // model_start, model_routed, skill_inspector, … are APX-internal
+        // progress events with no ACP counterpart.
+        return;
+    }
+  }
+
+  async #requestPermission(session, turn, event) {
+    let confirmed = false;
+    try {
+      const res = await this.connection.request("session/request_permission", {
+        sessionId: session.id,
+        toolCall: {
+          toolCallId: turn.lastToolCallId || String(event.correlationId),
+          title: String(event.description || event.tool || "tool call"),
+        },
+        options: [
+          { optionId: "allow", name: "Allow", kind: "allow_once" },
+          { optionId: "reject", name: "Reject", kind: "reject_once" },
+        ],
+      });
+      const outcome = res?.outcome;
+      confirmed = outcome?.outcome === "selected" && outcome.optionId === "allow";
+    } catch (e) {
+      // Client gone or errored — never self-approve.
+      this.#logError("permission request failed", e);
+      confirmed = false;
+    }
+    try {
+      await this.client.post(
+        `/super-agent/confirm/${encodeURIComponent(event.correlationId)}`,
+        { confirmed }
+      );
+    } catch (e) {
+      // The pending-store entry times out on its own; log and move on.
+      this.#logError("confirm resolution failed", e);
+    }
+  }
+}
+
+/** Run the ACP agent on the current process stdio against the local daemon. */
+export async function startStdioAcpServer() {
+  // Lazy import: the CLI http helper auto-starts the daemon; tests never
+  // reach this path (they inject their own base URL).
+  const { ensureDaemon } = await import("#interfaces/cli/http.js");
+  const host = process.env.APX_HOST || "127.0.0.1";
+  const port = parseInt(process.env.APX_PORT || "7430", 10);
+  const tokenPath = path.join(APX_HOME, "daemon.token");
+  const server = new AcpAgentServer({
+    input: process.stdin,
+    output: process.stdout,
+    daemon: {
+      baseUrl: `http://${host}:${port}`,
+      // Re-read per request so a daemon restart with a rotated token mid-
+      // session keeps working.
+      token: () => {
+        try {
+          return fs.readFileSync(tokenPath, "utf8").trim();
+        } catch {
+          return "";
+        }
+      },
+    },
+    ensureDaemon: () => ensureDaemon({ silent: true }),
+  });
+  server.start();
+  await server.whenClosed();
+}
+
+const isMain =
+  process.argv[1] && import.meta.url === pathToFileURL(path.resolve(process.argv[1])).href;
+if (isMain) {
+  startStdioAcpServer().catch((e) => {
+    process.stderr.write(`apx acp: fatal: ${e?.message || e}\n`);
+    process.exit(1);
+  });
+}