@agentprojectcontext/apx 1.77.2 → 1.78.0

package/src/core/stores/code-sessions.js

@@ -14,6 +14,7 @@ import path from "node:path";
 import { nowIso } from "../util/time.js";
 import { shortId as makeShortId } from "../util/ids.js";
 import { CODE_MODES, DEFAULT_CODE_MODE } from "../constants/code-modes.js";
+import { readJson, writeJson } from "#core/util/json-file.js";
 
 function sessionsDir(storagePath) {
   return path.join(storagePath, "code-sessions");
@@ -28,20 +29,8 @@ function shortId() {
 }
 
 // Atomic write: tmp file + rename so a crash mid-write can't corrupt a session.
-function writeJson(file, obj) {
-  fs.mkdirSync(path.dirname(file), { recursive: true });
-  const tmp = `${file}.${process.pid}.tmp`;
-  fs.writeFileSync(tmp, JSON.stringify(obj, null, 2));
-  fs.renameSync(tmp, file);
-}
-
-function readJson(file) {
-  try {
-    return JSON.parse(fs.readFileSync(file, "utf8"));
-  } catch {
-    return null;
-  }
-}
+// readJson/writeJson come from the shared kernel (this module's atomic write
+// was the one the others were missing).
 
 /** Lightweight row for the session list (no messages). */
 function toRow(s) {

package/src/core/stores/engine-sessions.js

@@ -13,10 +13,6 @@ import path from "node:path";
 
 const homeDir = (opts) => (opts && opts.home) || os.homedir();
 
-function encodeClaudeProjectPath(cwd) {
-  return String(cwd || "").replace(/[^A-Za-z0-9]/g, "-");
-}
-
 function safeStatMtime(p) {
   try {
     return fs.statSync(p).mtimeMs;

package/src/core/stores/messages.js

@@ -29,11 +29,6 @@ function dayPathJsonl(projectRoot, ts) {
   return path.join(projectRoot, "messages", `${day}.jsonl`);
 }
 
-function dayPathMd(projectRoot, ts) {
-  const day = (ts || nowIso()).slice(0, 10);
-  return path.join(projectRoot, "messages", `${day}.md`);
-}
-
 // `compact` is a progressive-compaction summary record (Pieza 3): a dense
 // recap of older turns, stored inline in the channel JSONL so the reader can
 // prepend it as a [RESUMEN COMPACTADO] system turn instead of replaying the

package/src/core/stores/organization.js

@@ -19,6 +19,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import { apcOrganizationFile } from "../apc/paths.js";
+import { readJson } from "#core/util/json-file.js";
 
 export const ORG_SLUG_RE = /^[a-z][a-z0-9_-]*$/;
 
@@ -39,17 +40,14 @@ function emptyOrg() {
 
 export function readOrganization(root) {
   const file = apcOrganizationFile(root);
-  if (!fs.existsSync(file)) return emptyOrg();
-  try {
-    const raw = JSON.parse(fs.readFileSync(file, "utf8"));
-    return {
-      areas: Array.isArray(raw.areas) ? raw.areas : [],
-      roles: Array.isArray(raw.roles) ? raw.roles : [],
-    };
-  } catch {
-    // A corrupt file shouldn't take down the whole project view.
-    return emptyOrg();
-  }
+  // A missing or corrupt file shouldn't take down the whole project view —
+  // readJson returns the fallback for both.
+  const raw = readJson(file, null);
+  if (!raw) return emptyOrg();
+  return {
+    areas: Array.isArray(raw.areas) ? raw.areas : [],
+    roles: Array.isArray(raw.roles) ? raw.roles : [],
+  };
 }
 
 function writeOrganization(root, org) {

package/src/core/stores/routines.js

@@ -5,6 +5,7 @@ import path from "node:path";
 import { CronExpressionParser } from "cron-parser";
 import { nowIso, isoToMs } from "../util/time.js";
 import { shortId } from "../util/ids.js";
+import { readJson, writeJson } from "#core/util/json-file.js";
 
 function routinesPath(storagePath) {
   // storagePath is always ~/.apx/projects/{apxId}/ — flat, no .apc subdir needed.
@@ -12,20 +13,14 @@ function routinesPath(storagePath) {
 }
 
 function readFile(projectPath) {
-  const p = routinesPath(projectPath);
-  if (!fs.existsSync(p)) return [];
-  try {
-    const raw = JSON.parse(fs.readFileSync(p, "utf8"));
-    return Array.isArray(raw.routines) ? raw.routines : [];
-  } catch {
-    return [];
-  }
+  const raw = readJson(routinesPath(projectPath), {});
+  return Array.isArray(raw?.routines) ? raw.routines : [];
 }
 
+// Atomic: a crash mid-write used to leave a truncated routines.json, and since
+// the reader swallows parse errors the next read reported "no routines".
 function writeFile(projectPath, routines) {
-  const p = routinesPath(projectPath);
-  fs.mkdirSync(path.dirname(p), { recursive: true });
-  fs.writeFileSync(p, JSON.stringify({ routines }, null, 2) + "\n");
+  writeJson(routinesPath(projectPath), { routines });
 }
 
 // --------------------- schedule parsing -------------------------------------

package/src/core/stores/runtime-callbacks.js

@@ -18,6 +18,7 @@ import fs from "node:fs";
 import path from "node:path";
 import { APX_HOME } from "#core/config/paths.js";
 import { nowIso } from "#core/util/time.js";
+import { readJson } from "#core/util/json-file.js";
 
 export const PENDING_CALLBACKS_DIR = path.join(APX_HOME, "pending-callbacks");
 
@@ -63,7 +64,7 @@ export function listPendingCallbacks() {
   const out = [];
   for (const f of files) {
     try {
-      const entry = JSON.parse(fs.readFileSync(path.join(PENDING_CALLBACKS_DIR, f), "utf8"));
+      const entry = readJson(path.join(PENDING_CALLBACKS_DIR, f), null);
       if (entry?.session_id) out.push(entry);
     } catch {
       /* skip corrupt */

package/src/core/util/json-file.js

@@ -0,0 +1,128 @@
+// JSON files on disk — one implementation.
+//
+// Six modules had grown their own read/write pair and 35 more sites inlined
+// `JSON.parse(fs.readFileSync(...))`. They did not agree on the things that
+// matter, so the guarantees your data got depended on which copy happened to
+// touch it:
+//
+//   - Atomicity. Only core/stores/code-sessions.js wrote through a temp file
+//     and renamed. Everywhere else, a crash or a full disk mid-write left a
+//     truncated file — and since the readers swallow parse errors, the next
+//     read silently returned "empty" instead of "corrupt". routines.json and
+//     the MCP stores were exposed to that.
+//   - Permissions. vars and mcp chmod 0600 because they hold tokens; the
+//     others did not, so the same kind of data could land world-readable
+//     depending on the writer.
+//   - Missing-file semantics. Some returned null, some {}, some threw.
+//
+// Reads are forgiving by design (a missing or corrupt file yields the caller's
+// fallback), because every caller here treats "no data" as a valid state.
+// Writes are strict: they create the directory, write atomically, and throw if
+// they cannot.
+import fs from "node:fs";
+import fsp from "node:fs/promises";
+import path from "node:path";
+
+/** Mode for files that may contain tokens or credentials. */
+export const SECRET_MODE = 0o600;
+
+// Twelve call sites still parse inline, on purpose. They are the ones whose
+// failure mode is not "fall back to empty":
+//
+//   config/index.js       a corrupt ~/.apx/config.json must THROW, loudly. Its
+//                         silent fallback would be an empty config, i.e. every
+//                         key reset — the worst possible recovery.
+//   mcp/sources.js,       these report *which* file failed and why, so the user
+//   integrations/sources  can fix it; a bare fallback would hide the problem.
+//   profiles/lifecycle,   these read package.json / manifests where a parse
+//   project-config, …     error is a real error, not a missing-file state.
+//
+// If you are adding a new read whose answer on failure is "treat it as empty",
+// use readJson. If it is "tell the user", keep it explicit.
+
+/**
+ * Read and parse a JSON file.
+ *
+ * @param {string} file
+ * @param {unknown} [fallback=null] returned when the file is missing, empty or
+ *   unparseable. Pass `{}` or `[]` when the caller wants a shape it can spread.
+ */
+export function readJson(file, fallback = null) {
+  let raw;
+  try {
+    raw = fs.readFileSync(file, "utf8");
+  } catch {
+    return fallback; // missing file is a normal state, not an error
+  }
+  if (!raw.trim()) return fallback;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return fallback;
+  }
+}
+
+/** Async variant, for request paths that must not block the event loop. */
+export async function readJsonAsync(file, fallback = null) {
+  let raw;
+  try {
+    raw = await fsp.readFile(file, "utf8");
+  } catch {
+    return fallback;
+  }
+  if (!raw.trim()) return fallback;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return fallback;
+  }
+}
+
+/**
+ * Write a value as pretty JSON, atomically.
+ *
+ * Writes to `<file>.<pid>.tmp` and renames, so a reader never observes a
+ * half-written file and a crash cannot destroy the previous contents.
+ *
+ * @param {string} file
+ * @param {unknown} value
+ * @param {{ mode?: number }} [opts] `mode: SECRET_MODE` for files holding
+ *   credentials.
+ */
+export function writeJson(file, value, { mode } = {}) {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const tmp = `${file}.${process.pid}.tmp`;
+  try {
+    fs.writeFileSync(tmp, JSON.stringify(value, null, 2) + "\n");
+    if (mode !== undefined) fs.chmodSync(tmp, mode);
+    fs.renameSync(tmp, file);
+  } catch (err) {
+    // Never leave the temp file behind on a failed write.
+    try { fs.unlinkSync(tmp); } catch { /* already gone */ }
+    throw err;
+  }
+}
+
+/** Async variant. Same atomic rename. */
+export async function writeJsonAsync(file, value, { mode } = {}) {
+  await fsp.mkdir(path.dirname(file), { recursive: true });
+  const tmp = `${file}.${process.pid}.tmp`;
+  try {
+    await fsp.writeFile(tmp, JSON.stringify(value, null, 2) + "\n");
+    if (mode !== undefined) await fsp.chmod(tmp, mode);
+    await fsp.rename(tmp, file);
+  } catch (err) {
+    try { await fsp.unlink(tmp); } catch { /* already gone */ }
+    throw err;
+  }
+}
+
+/**
+ * Read, transform, write back — atomically, with the same fallback rules.
+ * Returns the value that was written.
+ */
+export function updateJson(file, updater, { fallback = null, mode } = {}) {
+  const next = updater(readJson(file, fallback));
+  writeJson(file, next, { mode });
+  return next;
+}

package/src/core/vars/sources.js

@@ -13,16 +13,16 @@
 //
 // project wins over global when the same name exists in both.
 
-import fs from "node:fs";
-import os from "node:os";
 import path from "node:path";
+import { apxHome } from "#core/config/paths.js";
+import { readJson, writeJson, SECRET_MODE } from "#core/util/json-file.js";
 
-const APX_HOME = path.join(os.homedir(), ".apx");
-const GLOBAL_VARS_FILE = path.join(APX_HOME, "vars.json");
+
+const globalVarsFile = () => path.join(apxHome(), "vars.json");
 const PROJECT_VARS_FILENAME = "vars.json";
 
 export function globalVarsPath() {
-  return GLOBAL_VARS_FILE;
+  return globalVarsFile();
 }
 
 export function projectVarsPath(storagePath) {
@@ -30,32 +30,25 @@ export function projectVarsPath(storagePath) {
   return path.join(storagePath, PROJECT_VARS_FILENAME);
 }
 
+// A vars file must be a plain object; anything else is treated as empty.
 function readJsonSafe(absPath) {
-  if (!absPath || !fs.existsSync(absPath)) return {};
-  try {
-    const json = JSON.parse(fs.readFileSync(absPath, "utf8"));
-    return json && typeof json === "object" && !Array.isArray(json) ? json : {};
-  } catch {
-    return {};
-  }
+  if (!absPath) return {};
+  const json = readJson(absPath, {});
+  return json && typeof json === "object" && !Array.isArray(json) ? json : {};
 }
 
+// SECRET_MODE: these files hold tokens. The write is atomic, so a crash can no
+// longer truncate the store.
 function writeJsonSecure(absPath, obj) {
-  fs.mkdirSync(path.dirname(absPath), { recursive: true });
-  fs.writeFileSync(absPath, JSON.stringify(obj, null, 2) + "\n");
-  try {
-    fs.chmodSync(absPath, 0o600);
-  } catch {
-    // Best effort on non-POSIX filesystems.
-  }
+  writeJson(absPath, obj, { mode: SECRET_MODE });
 }
 
 export function readGlobalVars() {
-  return readJsonSafe(GLOBAL_VARS_FILE);
+  return readJsonSafe(globalVarsFile());
 }
 
 export function writeGlobalVars(obj) {
-  writeJsonSecure(GLOBAL_VARS_FILE, obj);
+  writeJsonSecure(globalVarsFile(), obj);
 }
 
 export function readProjectVars(storagePath) {

package/src/core/voice/stt-models.js

@@ -23,7 +23,7 @@ function repoCacheName(repoId) {
 
 function dirSizeBytes(dir) {
   let total = 0;
-  let stack = [dir];
+  const stack = [dir];
   while (stack.length) {
     const d = stack.pop();
     let entries;

package/src/core/voice/tts.js

@@ -5,11 +5,12 @@
 //
 // All audio files land under ~/.apx/tmp/tts/<uuid>.<ext>. Callers are
 // responsible for cleaning up (Telegram plugin already uses similar temp
-// files via /telegram/send_voice).
+// files via /api/telegram/send_voice).
 
 import fs from "node:fs";
-import path from "node:path";
-import os from "node:os";
+import { TTS_TMP_DIR } from "#core/config/paths.js";
+
+export { TTS_TMP_DIR };
 import { readConfig } from "../config/index.js";
 import {
   selectTtsEngine,
@@ -19,7 +20,7 @@ import {
 } from "./engines/index.js";
 import { emotionConfigFor, stripEmotionTags } from "./emotions.js";
 
-export const TTS_TMP_DIR = path.join(os.homedir(), ".apx", "tmp", "tts");
+
 
 export function ensureTtsTmpDir() {
   fs.mkdirSync(TTS_TMP_DIR, { recursive: true });

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

@@ -8,7 +8,7 @@
 import { readConfig, writeConfig } from "#core/config/index.js";
 import { resolveAgentName } from "#core/identity/index.js";
 import { setDottedKey, unsetDottedKey } from "../project-config.js";
-import { PERMISSION_MODES, DEFAULT_PERMISSION_MODE } from "#core/constants/permissions.js";
+import { PERMISSION_MODES } from "#core/constants/permissions.js";
 import {
   redactConfig as redact,
   isSecretMarker,
@@ -16,8 +16,8 @@ import {
 } 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) => {
+export function register(api, { config, scheduler, plugins }) {
+  api.get("/admin/config", (_req, res) => {
     try {
       const fresh = readConfig();
       res.json({ config: redact(fresh) });
@@ -26,7 +26,7 @@ export function register(app, { config, scheduler, plugins }) {
     }
   });
 
-  app.patch("/admin/config", (req, res) => {
+  api.patch("/admin/config", (req, res) => {
     const { set, unset } = req.body || {};
     let cfg;
     try {
@@ -68,7 +68,7 @@ export function register(app, { config, scheduler, plugins }) {
   });
 
   // Convenience: GET the resolved super_agent prompt (used by SettingsScreen)
-  app.get("/admin/super-agent", (_req, res) => {
+  api.get("/admin/super-agent", (_req, res) => {
     try {
       const fresh = readConfig();
       const sa = fresh.super_agent || {};

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

@@ -8,11 +8,12 @@ import { execFile } from "node:child_process";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
+import { LOG_DIR } from "#core/config/paths.js";
 
-export function register(app, { scheduler, plugins, config, registries }) {
+export function register(api, { scheduler, plugins, config, registries }) {
   // Daemon logs: errors.jsonl (structured) or apx.log (plain), newest first.
-  app.get("/admin/logs", (req, res) => {
-    const dir = path.join(os.homedir(), ".apx", "logs");
+  api.get("/admin/logs", (req, res) => {
+    const dir = LOG_DIR;
     const which = req.query.file === "apx" ? "apx.log" : "errors.jsonl";
     const file = path.join(dir, which);
     const limit = Math.min(parseInt(req.query.limit, 10) || 200, 2000);
@@ -26,7 +27,7 @@ export function register(app, { scheduler, plugins, config, registries }) {
     res.json({ file: which, lines: tail });
   });
 
-  app.post("/admin/reload", (_req, res) => {
+  api.post("/admin/reload", (_req, res) => {
     try {
       const fresh = readConfig();
       // Mutate in place so every closure that captured `config` sees the new
@@ -46,7 +47,7 @@ export function register(app, { scheduler, plugins, config, registries }) {
     }
   });
 
-  app.post("/admin/shutdown", (_req, res) => {
+  api.post("/admin/shutdown", (_req, res) => {
     res.json({ ok: true });
     setTimeout(() => process.exit(0), 50);
   });
@@ -56,7 +57,7 @@ export function register(app, { scheduler, plugins, config, registries }) {
   // zenity (if present); Windows uses PowerShell's Shell.Application. If the
   // platform lacks a usable picker — or none is installed — the endpoint
   // returns 501 so the frontend can fall back to the inline directory list.
-  app.get("/admin/fs/pick-dir", (req, res) => {
+  api.get("/admin/fs/pick-dir", (req, res) => {
     // The prompt is attacker-controllable (query string). NEVER interpolate it
     // into a shell string — use execFile (no shell) with an argv array, and
     // pass the prompt out-of-band via an env var so it can't break out of any
@@ -109,7 +110,7 @@ export function register(app, { scheduler, plugins, config, registries }) {
     });
   });
 
-  app.get("/admin/fs/dirs", (req, res) => {
+  api.get("/admin/fs/dirs", (req, res) => {
     const requested = String(req.query.path || os.homedir());
     const base = path.resolve(requested.replace(/^~(?=$|\/)/, os.homedir()));
     try {

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

@@ -70,12 +70,12 @@ function normalizeAutonomy(v) {
   return AUTONOMY_VALUES.has(v) ? v : undefined;
 }
 
-export function register(app, { projects, project }) {
+export function register(api, { projects, project }) {
   // Vault = global agent templates. Two-layer: bundled defaults shipped with
   // APX (assets/agent-vault-defaults/) + user overrides/new ones in
   // ~/.apx/agents/. The user layer wins per slug; tombstones in .removed.json
   // hide bundled entries. GET merges both with `source` set per item.
-  app.get("/agents/vault", (req, res) => {
+  api.get("/agents/vault", (req, res) => {
     const includeRemoved = req.query?.include_removed === "1";
     res.json(readVaultAgents({ includeRemoved }).map((a) => ({
       ...agentToResponse(a),
@@ -84,7 +84,7 @@ export function register(app, { projects, project }) {
   });
 
   // Create or replace a vault template (user layer / copy-on-write).
-  app.post("/agents/vault", (req, res) => {
+  api.post("/agents/vault", (req, res) => {
     const { slug, fields, body = "" } = req.body || {};
     if (!slug || !/^[a-z][a-z0-9_-]*$/.test(slug)) {
       return res.status(400).json({ error: "valid slug required" });
@@ -100,7 +100,7 @@ export function register(app, { projects, project }) {
 
   // Patch a vault template. If the slug is bundled-only, copy it to the user
   // layer first (the writer already does this), then apply the merged fields.
-  app.patch("/agents/vault/:slug", (req, res) => {
+  api.patch("/agents/vault/:slug", (req, res) => {
     const { slug } = req.params;
     const current = readVaultAgent(slug);
     if (!current) return res.status(404).json({ error: `vault agent ${slug} not found` });
@@ -118,14 +118,14 @@ export function register(app, { projects, project }) {
 
   // Delete a vault template. Tombstones bundled slugs so they stay hidden;
   // deletes the user-layer file otherwise. POST .../restore lifts a tombstone.
-  app.delete("/agents/vault/:slug", (req, res) => {
+  api.delete("/agents/vault/:slug", (req, res) => {
     const { slug } = req.params;
     const out = removeVaultAgent(slug);
     if (!out.removed) return res.status(404).json({ error: `vault agent ${slug} not found` });
     res.json({ ok: true, ...out });
   });
 
-  app.post("/agents/vault/:slug/restore", (req, res) => {
+  api.post("/agents/vault/:slug/restore", (req, res) => {
     const { slug } = req.params;
     const out = restoreVaultAgent(slug);
     if (!out.restored) return res.status(404).json({ error: `slug ${slug} was not tombstoned` });
@@ -134,7 +134,7 @@ export function register(app, { projects, project }) {
   });
 
   // Import a vault template into a project (copies it to .apc/agents/<slug>.md).
-  app.post("/projects/:pid/agents/import", (req, res) => {
+  api.post("/projects/:pid/agents/import", (req, res) => {
     const p = project(req, res);
     if (!p) return;
     const { slug } = req.body || {};
@@ -154,7 +154,7 @@ export function register(app, { projects, project }) {
     }
   });
 
-  app.get("/projects/:pid/agents", (req, res) => {
+  api.get("/projects/:pid/agents", (req, res) => {
     const p = project(req, res);
     if (!p) return;
     const agents = readAgents(p.path).map(agentToResponse);
@@ -162,7 +162,7 @@ export function register(app, { projects, project }) {
     res.json(agents);
   });
 
-  app.get("/projects/:pid/agents/:slug", (req, res) => {
+  api.get("/projects/:pid/agents/:slug", (req, res) => {
     const p = project(req, res);
     if (!p) return;
     const agents = readAgents(p.path);
@@ -172,7 +172,7 @@ export function register(app, { projects, project }) {
     res.json({ ...agentToResponse(a), memory, system: a.body || "" });
   });
 
-  app.post("/projects/:pid/agents", (req, res) => {
+  api.post("/projects/:pid/agents", (req, res) => {
     const p = project(req, res);
     if (!p) return;
     const {
@@ -213,7 +213,7 @@ export function register(app, { projects, project }) {
 
   // Edit an existing agent. Merges provided fields into the AGENT.md
   // frontmatter; `system` rewrites the body (the agent's system prompt).
-  app.patch("/projects/:pid/agents/:slug", (req, res) => {
+  api.patch("/projects/:pid/agents/:slug", (req, res) => {
     const p = project(req, res);
     if (!p) return;
     const slug = req.params.slug;
@@ -255,7 +255,7 @@ export function register(app, { projects, project }) {
   });
 
   // Delete an agent: removes .apc/agents/<slug>.md and runtime data dir.
-  app.delete("/projects/:pid/agents/:slug", (req, res) => {
+  api.delete("/projects/:pid/agents/:slug", (req, res) => {
     const p = project(req, res);
     if (!p) return;
     const slug = req.params.slug;
@@ -276,7 +276,7 @@ export function register(app, { projects, project }) {
   });
 
   // ---- Project-level memory (.apc/memory.md) ----
-  app.get("/projects/:pid/memory", (req, res) => {
+  api.get("/projects/:pid/memory", (req, res) => {
     const p = project(req, res);
     if (!p) return;
     const memPath = apcMemoryFile(p.path);
@@ -284,7 +284,7 @@ export function register(app, { projects, project }) {
     res.json({ body, path: memPath });
   });
 
-  app.put("/projects/:pid/memory", (req, res) => {
+  api.put("/projects/:pid/memory", (req, res) => {
     const p = project(req, res);
     if (!p) return;
     const { body } = req.body || {};
@@ -298,7 +298,7 @@ export function register(app, { projects, project }) {
   });
 
   // ---- Per-agent memory ----
-  app.get("/projects/:pid/agents/:slug/memory", (req, res) => {
+  api.get("/projects/:pid/agents/:slug/memory", (req, res) => {
     const p = project(req, res);
     if (!p) return;
     // Validate the agent exists — otherwise an unknown slug returned 200 with an
@@ -308,7 +308,7 @@ export function register(app, { projects, project }) {
     res.json({ body: readAgentMemory(p, req.params.slug) });
   });
 
-  app.put("/projects/:pid/agents/:slug/memory", (req, res) => {
+  api.put("/projects/:pid/agents/:slug/memory", (req, res) => {
     const p = project(req, res);
     if (!p) return;
     if (!readAgents(p.path).some((a) => a.slug === req.params.slug))

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

@@ -12,9 +12,9 @@
 import { previews } from "#core/artifacts/preview.js";
 import { tunnels, detectProviders } from "#core/artifacts/tunnel.js";
 
-export function register(app, { project }) {
+export function register(api, { project }) {
   // Start (or reuse) an ephemeral preview server for an artifact.
-  app.post("/projects/:pid/artifacts/:name/preview", async (req, res) => {
+  api.post("/projects/:pid/artifacts/:name/preview", async (req, res) => {
     const p = project(req, res);
     if (!p) return;
     const name = decodeURIComponent(req.params.name);
@@ -33,24 +33,24 @@ export function register(app, { project }) {
   });
 
   // List preview servers scoped to a project.
-  app.get("/projects/:pid/previews", (req, res) => {
+  api.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) => {
+  api.get("/previews", (_req, res) => {
     res.json(previews.list());
   });
 
   // Which tunnel providers this host can use, best first.
-  app.get("/previews/tunnel-providers", (_req, res) => {
+  api.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) => {
+  api.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);
@@ -58,7 +58,7 @@ export function register(app, { project }) {
   });
 
   // Open a public tunnel to a preview's local port.
-  app.post("/previews/:id/tunnel", async (req, res) => {
+  api.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
@@ -72,7 +72,7 @@ export function register(app, { project }) {
   });
 
   // Close a preview's tunnel but keep the local server running.
-  app.delete("/previews/:id/tunnel", (req, res) => {
+  api.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);