@docyrus/docyrus 0.0.69 → 0.0.71

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@docyrus/docyrus",
-  "version": "0.0.69",
+  "version": "0.0.71",
   "private": false,
   "description": "Docyrus API CLI",
   "main": "./main.js",
@@ -14,8 +14,8 @@
     "@clack/prompts": "^0.11.0",
     "@ff-labs/fff-node": "0.6.4",
     "@hono/node-server": "^1.19.13",
-    "@mariozechner/pi-ai": "0.70.6",
-    "@mariozechner/pi-coding-agent": "0.70.6",
+    "@mariozechner/pi-ai": "0.71.1",
+    "@mariozechner/pi-coding-agent": "0.71.1",
     "@modelcontextprotocol/ext-apps": "^1.2.2",
     "@modelcontextprotocol/sdk": "^1.25.1",
     "@mozilla/readability": "^0.6.0",

package/server-loader.js

@@ -18788,6 +18788,11 @@ var DEFAULT_LOGIN_SCOPES = [
 var DOCYRUS_SETTINGS_DIR_NAME = ".docyrus";
 var DOCYRUS_PI_DIR_NAME = "pi";
 var DOCYRUS_PI_AGENT_DIR_NAME = "agent";
+var DOCYRUS_TRACKED_DIR_NAME = "docyrus";
+var DOCYRUS_TRACKED_AGENT_DIR_NAME = "agent";
+var DOCYRUS_TRACKED_KNOWLEDGE_INDEX_DIR_NAME = "knowledge-index";
+var DOCYRUS_TRACKED_SESSION_CONFIG_DIR_NAME = "session-config";
+var DOCYRUS_TRACKED_SKILLS_DIR_NAME = "skills";
 var AUTH_DIR_PATH = (0, import_node_path3.join)((0, import_node_os.homedir)(), DOCYRUS_SETTINGS_DIR_NAME);
 var AUTH_FILE_PATH = (0, import_node_path3.join)(AUTH_DIR_PATH, "auth.json");
 var CONFIG_FILE_PATH = (0, import_node_path3.join)(AUTH_DIR_PATH, "config.json");
@@ -18823,6 +18828,21 @@ var DEFAULT_ENVIRONMENTS = [
     apiBaseUrl: "https://localhost:3366"
   }
 ];
+function getLocalDocyrusTrackedRootPath(cwd = process.cwd()) {
+  return (0, import_node_path3.join)(cwd, DOCYRUS_TRACKED_DIR_NAME);
+}
+function resolveDocyrusTrackedAgentRootPath(cwd = process.cwd()) {
+  return (0, import_node_path3.join)(getLocalDocyrusTrackedRootPath(cwd), DOCYRUS_TRACKED_AGENT_DIR_NAME);
+}
+function resolveDocyrusTrackedSessionConfigRootPath(cwd = process.cwd()) {
+  return (0, import_node_path3.join)(resolveDocyrusTrackedAgentRootPath(cwd), DOCYRUS_TRACKED_SESSION_CONFIG_DIR_NAME);
+}
+function resolveDocyrusTrackedSkillsRootPath(cwd = process.cwd()) {
+  return (0, import_node_path3.join)(resolveDocyrusTrackedAgentRootPath(cwd), DOCYRUS_TRACKED_SKILLS_DIR_NAME);
+}
+function resolveDocyrusKnowledgeIndexRootPath(cwd = process.cwd()) {
+  return (0, import_node_path3.join)(getLocalDocyrusTrackedRootPath(cwd), DOCYRUS_TRACKED_KNOWLEDGE_INDEX_DIR_NAME);
+}
 function normalizeApiBaseUrl(apiBaseUrl) {
   const trimmed = apiBaseUrl.trim();
   if (!trimmed) {
@@ -35602,6 +35622,25 @@ function parseAskUserResponseFromToolOutput(output) {
 }
 
 // src/server/eventBridge.ts
+function extractAssistantEventErrorMessage(error48) {
+  if (error48 instanceof Error) {
+    return error48.message;
+  }
+  if (typeof error48 === "string") {
+    return error48;
+  }
+  if (error48 && typeof error48 === "object") {
+    const candidate = error48.errorMessage;
+    if (typeof candidate === "string" && candidate.trim().length > 0) {
+      return candidate;
+    }
+    const reason = error48.stopReason;
+    if (typeof reason === "string" && reason.trim().length > 0) {
+      return `Agent stopped: ${reason}`;
+    }
+  }
+  return "Unknown agent error";
+}
 function createEventBridge(params) {
   const { messageId, onChunk, onDone, onError, onAskUser } = params;
   const activeToolCalls = /* @__PURE__ */ new Map();
@@ -35653,12 +35692,27 @@ function createEventBridge(params) {
         handleToolExecutionEnd(event);
         break;
       }
+      case "message_end": {
+        handleMessageEnd(event);
+        break;
+      }
       case "agent_end": {
         onDone();
         break;
       }
     }
   }
+  function handleMessageEnd(event) {
+    const message = event.message;
+    if (!message) {
+      return;
+    }
+    const stopReason = message.stopReason;
+    if (stopReason !== "error" && stopReason !== "aborted") {
+      return;
+    }
+    onError(extractAssistantEventErrorMessage(message));
+  }
   function handleMessageUpdate(event) {
     const assistantEvent = event.assistantMessageEvent;
     if (!assistantEvent) {
@@ -35759,8 +35813,7 @@ function createEventBridge(params) {
         break;
       }
       case "error": {
-        const errorMessage = assistantEvent.error instanceof Error ? assistantEvent.error.message : typeof assistantEvent.error === "string" ? assistantEvent.error : "Unknown agent error";
-        onError(errorMessage);
+        onError(extractAssistantEventErrorMessage(assistantEvent.error));
         break;
       }
     }
@@ -41120,14 +41173,11 @@ function readJsonFile(filePath) {
     return null;
   }
 }
-function hashWorkspace(projectRoot) {
-  return (0, import_node_crypto.createHash)("sha256").update((0, import_node_path12.resolve)(projectRoot)).digest("hex").slice(0, 16);
-}
-function resolveKnowledgeCacheRoot(settingsRootPath, projectRoot) {
-  return (0, import_node_path12.join)(settingsRootPath, "knowledge", hashWorkspace(projectRoot));
+function resolveKnowledgeCacheRoot(projectRoot) {
+  return resolveDocyrusKnowledgeIndexRootPath(projectRoot);
 }
-function resolveKnowledgeVectorsDbPath(settingsRootPath, projectRoot) {
-  return (0, import_node_path12.join)(resolveKnowledgeCacheRoot(settingsRootPath, projectRoot), "vectors.db");
+function resolveKnowledgeVectorsDbPath(projectRoot) {
+  return (0, import_node_path12.join)(resolveKnowledgeCacheRoot(projectRoot), "vectors.db");
 }
 function normalizeApiBase(apiBase) {
   const trimmed = apiBase.trim().replace(/\/+$/u, "");
@@ -41304,12 +41354,12 @@ function createKnowledgeDb(db) {
     }
   };
 }
-function openKnowledgeDb(settingsRootPath, projectRoot) {
-  const cacheRoot = resolveKnowledgeCacheRoot(settingsRootPath, projectRoot);
+function openKnowledgeDb(projectRoot) {
+  const cacheRoot = resolveKnowledgeCacheRoot(projectRoot);
   if (!(0, import_node_fs4.existsSync)(cacheRoot)) {
     (0, import_node_fs4.mkdirSync)(cacheRoot, { recursive: true });
   }
-  return createKnowledgeDb(new import_promise.default(resolveKnowledgeVectorsDbPath(settingsRootPath, projectRoot), {}));
+  return createKnowledgeDb(new import_promise.default(resolveKnowledgeVectorsDbPath(projectRoot), {}));
 }
 async function ensureKnowledgeSchema(db, dimensions) {
   await db.execute(
@@ -41364,7 +41414,7 @@ function hashContent(text3) {
   return (0, import_node_crypto.createHash)("sha256").update(text3).digest("hex");
 }
 async function indexKnowledgeSections(params) {
-  const db = openKnowledgeDb(params.settingsRootPath, params.projectRoot);
+  const db = openKnowledgeDb(params.projectRoot);
   try {
     await ensureKnowledgeSchema(db, params.provider.dimensions);
     const sections = flattenSections(await loadAllSections(params.knowledgeDir));
@@ -41434,7 +41484,7 @@ async function indexKnowledgeSections(params) {
   }
 }
 async function searchKnowledgeSections(params) {
-  const db = openKnowledgeDb(params.settingsRootPath, params.projectRoot);
+  const db = openKnowledgeDb(params.projectRoot);
   try {
     await ensureKnowledgeSchema(db, params.provider.dimensions);
     const [queryVector] = await embedTexts([params.query], params.provider);
@@ -42890,9 +42940,7 @@ async function clearProviderConfig(params) {
 // src/agent/providerCatalog.ts
 var OAUTH_ONLY_PROVIDER_IDS = /* @__PURE__ */ new Set([
   "github-copilot",
-  "openai-codex",
-  "google-gemini-cli",
-  "google-antigravity"
+  "openai-codex"
 ]);
 var PROVIDER_LABELS = {
   anthropic: "Anthropic (Claude)",
@@ -42916,8 +42964,6 @@ var PROVIDER_LABELS = {
   "opencode-go": "OpenCode Go",
   "kimi-coding": "Kimi Coding",
   "custom-openai": "Custom OpenAI-Compatible",
-  "google-gemini-cli": "Google Gemini CLI",
-  "google-antigravity": "Google Antigravity",
   "openai-codex": "OpenAI Codex",
   "github-copilot": "GitHub Copilot"
 };
@@ -42928,9 +42974,7 @@ var PROVIDER_HINTS = {
   "azure-openai-responses": "API key + base URL/resource + deployment",
   "amazon-bedrock": "AWS profile or access key pair",
   "openai-codex": "browser auth",
-  "github-copilot": "browser auth",
-  "google-gemini-cli": "browser auth",
-  "google-antigravity": "browser auth"
+  "github-copilot": "browser auth"
 };
 function humanizeProviderId(providerId) {
   return providerId.split("-").map((part) => {
@@ -44394,34 +44438,48 @@ async function installSkill(params) {
       );
     }
   }
-  const skillsDir = getSkillsDir(params.agentDir);
-  const destination = (0, import_node_path21.join)(skillsDir, skillName);
-  const existed = await dirExists(destination);
+  const tracked = params.request.track !== false;
+  const runtimeSkillsDir = getSkillsDir(params.agentDir);
+  const runtimeDestination = (0, import_node_path21.join)(runtimeSkillsDir, skillName);
+  const trackedDestination = tracked ? (0, import_node_path21.join)(params.trackedSkillsRoot, skillName) : "";
+  const runtimeExisted = await dirExists(runtimeDestination);
+  const trackedExisted = tracked ? await dirExists(trackedDestination) : false;
+  const existed = runtimeExisted || trackedExisted;
   if (existed && !params.request.overwrite) {
     throw new SkillError(
       "ALREADY_EXISTS",
       `Skill "${skillName}" already exists. Set overwrite=true to replace it.`
     );
   }
-  await (0, import_promises17.mkdir)(skillsDir, { recursive: true });
+  if (tracked) {
+    await (0, import_promises17.mkdir)(params.trackedSkillsRoot, { recursive: true });
+  }
+  await (0, import_promises17.mkdir)(runtimeSkillsDir, { recursive: true });
   switch (params.request.sourceType) {
-    case "local":
+    case "local": {
+      const primaryDestination = tracked ? trackedDestination : runtimeDestination;
       await copyLocalSkill({
         source: params.request.source,
         cwd: params.cwd,
-        destination
+        destination: primaryDestination
       });
+      if (tracked) {
+        await (0, import_promises17.rm)(runtimeDestination, { recursive: true, force: true });
+        await (0, import_promises17.cp)(trackedDestination, runtimeDestination, { recursive: true });
+      }
       break;
+    }
   }
-  const fmName = await readSkillFrontmatterName(destination);
-  const computedHash = await computeSkillHash(destination);
+  const fmName = await readSkillFrontmatterName(runtimeDestination);
+  const computedHash = await computeSkillHash(runtimeDestination);
   const installedAt = (/* @__PURE__ */ new Date()).toISOString();
   const lock = await readSkillsLockFile(params.agentDir);
   lock.skills[skillName] = {
     source: params.request.source,
     sourceType: params.request.sourceType,
     computedHash,
-    installedAt
+    installedAt,
+    tracked
   };
   await writeSkillsLockFile(params.agentDir, lock);
   return {
@@ -44431,7 +44489,8 @@ async function installSkill(params) {
     sourceType: params.request.sourceType,
     computedHash,
     installedAt,
-    overwritten: existed
+    overwritten: existed,
+    tracked
   };
 }
 async function uninstallSkill(params) {
@@ -44450,9 +44509,11 @@ async function uninstallSkill(params) {
     targetDir = detail.skill.directory;
   }
   const destination = (0, import_node_path21.join)(skillsDir, targetDir);
+  const trackedDestination = (0, import_node_path21.join)(params.trackedSkillsRoot, targetDir);
   const lock = await readSkillsLockFile(params.agentDir);
   const lockKey = lock.skills[targetDir] ? targetDir : lock.skills[params.name] ? params.name : null;
   await (0, import_promises17.rm)(destination, { recursive: true, force: true });
+  await (0, import_promises17.rm)(trackedDestination, { recursive: true, force: true });
   if (lockKey) {
     delete lock.skills[lockKey];
     await writeSkillsLockFile(params.agentDir, lock);
@@ -44732,23 +44793,22 @@ var BROWSER_TOOL_SCHEMAS = [
 var import_node_fs13 = require("node:fs");
 var path5 = __toESM(require("node:path"));
 var DEFAULT_CONFIG = { autoCommit: false };
-function configPath(agentDir, sessionId) {
-  return path5.join(agentDir, "session-config", `${sessionId}.json`);
+function configPath(sessionConfigDir, sessionId) {
+  return path5.join(sessionConfigDir, `${sessionId}.json`);
 }
-async function readSessionConfig(agentDir, sessionId) {
+async function readSessionConfig(sessionConfigDir, sessionId) {
   try {
-    const raw2 = await import_node_fs13.promises.readFile(configPath(agentDir, sessionId), "utf-8");
+    const raw2 = await import_node_fs13.promises.readFile(configPath(sessionConfigDir, sessionId), "utf-8");
     return { ...DEFAULT_CONFIG, ...JSON.parse(raw2) };
   } catch {
     return { ...DEFAULT_CONFIG };
   }
 }
-async function writeSessionConfig(agentDir, sessionId, patch) {
-  const dir = path5.join(agentDir, "session-config");
-  await import_node_fs13.promises.mkdir(dir, { recursive: true });
-  const current = await readSessionConfig(agentDir, sessionId);
+async function writeSessionConfig(sessionConfigDir, sessionId, patch) {
+  await import_node_fs13.promises.mkdir(sessionConfigDir, { recursive: true });
+  const current = await readSessionConfig(sessionConfigDir, sessionId);
   const next = { ...current, ...patch };
-  await import_node_fs13.promises.writeFile(configPath(agentDir, sessionId), JSON.stringify(next, null, 2), "utf-8");
+  await import_node_fs13.promises.writeFile(configPath(sessionConfigDir, sessionId), JSON.stringify(next, null, 2), "utf-8");
   return next;
 }
 
@@ -44954,9 +45014,7 @@ async function searchKnowledgeForServer(params) {
   if (!knowledgeDir) {
     return { knowledgeDir: null, provider: null, matches: [] };
   }
-  const provider = await getKnowledgeSearchProviderInfo({
-    settingsRootPath: params.settingsRootPath
-  });
+  const provider = await getKnowledgeSearchProviderInfo({});
   if (!provider.provider || !provider.info) {
     return {
       knowledgeDir,
@@ -44969,14 +45027,12 @@ async function searchKnowledgeForServer(params) {
   await indexKnowledgeSections({
     knowledgeDir,
     projectRoot: context.projectRoot,
-    settingsRootPath: params.settingsRootPath,
     provider: provider.provider
   });
   const matches = await searchKnowledgeSections({
     query: params.query,
     knowledgeDir,
     projectRoot: context.projectRoot,
-    settingsRootPath: params.settingsRootPath,
     limit: Math.max(1, Math.min(params.limit ?? 5, 50)),
     provider: provider.provider
   });
@@ -45420,13 +45476,27 @@ async function createAgentServer(params) {
         let extensionUICleanup;
         if (extensionUIBridge) {
           extensionUIBridge.setRequestHandler((request) => {
-            writeChunk(request);
+            const { type: _omit, id, ...rest } = request;
+            writeChunk({
+              type: "data-extension-ui-request",
+              id,
+              data: { type: _omit, id, ...rest },
+              transient: true
+            });
           });
           extensionUICleanup = () => {
             extensionUIBridge.setRequestHandler(() => {
             });
           };
         }
+        let errorChunkEmitted = false;
+        function writeErrorChunk(errorText) {
+          if (errorChunkEmitted) {
+            return;
+          }
+          errorChunkEmitted = true;
+          writeChunk({ type: "error", errorText });
+        }
         const bridge = createEventBridge({
           messageId,
           onChunk: writeChunk,
@@ -45435,13 +45505,17 @@ async function createAgentServer(params) {
           },
           onDone: () => {
             extensionUICleanup?.();
+            const sessionError = activeSession.errorMessage;
+            if (sessionError && sessionError.trim().length > 0) {
+              writeErrorChunk(sessionError);
+            }
             writeChunk({ type: "finish-step" });
             writeChunk({ type: "finish" });
             closeController();
           },
           onError: (errorText) => {
             extensionUICleanup?.();
-            writeChunk({ type: "error", errorText });
+            writeErrorChunk(errorText);
             writeChunk({ type: "finish-step" });
             writeChunk({ type: "finish" });
             closeController();
@@ -45457,6 +45531,10 @@ async function createAgentServer(params) {
           if (!activeSession.isStreaming) {
             unsubscribe();
             extensionUICleanup?.();
+            const sessionError = activeSession.errorMessage;
+            if (sessionError && sessionError.trim().length > 0) {
+              writeErrorChunk(sessionError);
+            }
             writeChunk({ type: "finish-step" });
             writeChunk({ type: "finish" });
             closeController();
@@ -45464,7 +45542,7 @@ async function createAgentServer(params) {
         }).catch((error48) => {
           const errorMessage = error48 instanceof Error ? error48.message : String(error48);
           extensionUICleanup?.();
-          writeChunk({ type: "error", errorText: errorMessage });
+          writeErrorChunk(errorMessage);
           writeChunk({ type: "finish-step" });
           writeChunk({ type: "finish" });
           unsubscribe();
@@ -45543,7 +45621,7 @@ async function createAgentServer(params) {
         return c.json({ error: "Created session is missing an id" }, 500);
       }
       if (body2.autoCommit !== void 0) {
-        await writeSessionConfig(context.agentDir, sessionId, { autoCommit: body2.autoCommit });
+        await writeSessionConfig(resolveDocyrusTrackedSessionConfigRootPath(context.cwd), sessionId, { autoCommit: body2.autoCommit });
       }
       const sessions = await sessionManager.list();
       const match2 = sessions.find((session) => session.id === sessionId);
@@ -45563,7 +45641,7 @@ async function createAgentServer(params) {
   app.get("/api/sessions/:sessionId/config", async (c) => {
     const sessionId = c.req.param("sessionId");
     try {
-      const config2 = await readSessionConfig(context.agentDir, sessionId);
+      const config2 = await readSessionConfig(resolveDocyrusTrackedSessionConfigRootPath(context.cwd), sessionId);
       return c.json({ sessionId, ...config2 });
     } catch (error48) {
       const message = error48 instanceof Error ? error48.message : String(error48);
@@ -45574,13 +45652,42 @@ async function createAgentServer(params) {
     const sessionId = c.req.param("sessionId");
     try {
       const body2 = await c.req.json();
-      const config2 = await writeSessionConfig(context.agentDir, sessionId, body2);
+      const config2 = await writeSessionConfig(resolveDocyrusTrackedSessionConfigRootPath(context.cwd), sessionId, body2);
       return c.json({ ok: true, sessionId, ...config2 });
     } catch (error48) {
       const message = error48 instanceof Error ? error48.message : String(error48);
       return c.json({ error: message }, 500);
     }
   });
+  app.delete("/api/sessions/:sessionId", async (c) => {
+    const sessionId = c.req.param("sessionId");
+    try {
+      const activeId = activeSession.id?.trim();
+      if (activeId && activeId === sessionId) {
+        return c.json({
+          error: "Cannot delete the active session. Create or switch to a different session first."
+        }, 409);
+      }
+      const sessions = await sessionManager.list();
+      const match2 = sessions.find((s) => s.id === sessionId);
+      if (!match2) {
+        return c.json({ error: "Session not found" }, 404);
+      }
+      if (match2.path) {
+        await (0, import_promises18.rm)(match2.path, { force: true });
+      }
+      const sessionConfigPath = (0, import_node_path22.join)(
+        resolveDocyrusTrackedSessionConfigRootPath(context.cwd),
+        `${sessionId}.json`
+      );
+      await (0, import_promises18.rm)(sessionConfigPath, { force: true }).catch(() => {
+      });
+      return c.body(null, 204);
+    } catch (error48) {
+      const message = error48 instanceof Error ? error48.message : String(error48);
+      return c.json({ error: message }, 500);
+    }
+  });
   app.get("/api/sessions/:sessionId/messages", async (c) => {
     const sessionId = c.req.param("sessionId");
     try {
@@ -45780,7 +45887,6 @@ async function createAgentServer(params) {
       const limit = Number(c.req.query("limit") ?? 5);
       const result = await searchKnowledgeForServer({
         cwd: context.cwd,
-        settingsRootPath,
         query,
         limit: Number.isFinite(limit) ? limit : 5
       });
@@ -47132,10 +47238,12 @@ async function createAgentServer(params) {
         source: body2.source,
         sourceType: body2.sourceType,
         name: body2.name,
-        overwrite: body2.overwrite === true
+        overwrite: body2.overwrite === true,
+        track: body2.track !== false
       };
       const result = await installSkill({
         agentDir: context.agentDir,
+        trackedSkillsRoot: resolveDocyrusTrackedSkillsRootPath(context.cwd),
         cwd: context.cwd,
         request
       });
@@ -47149,6 +47257,7 @@ async function createAgentServer(params) {
     try {
       const result = await uninstallSkill({
         agentDir: context.agentDir,
+        trackedSkillsRoot: resolveDocyrusTrackedSkillsRootPath(context.cwd),
         name: skillName
       });
       return c.json({ ok: true, ...result });
@@ -47307,6 +47416,8 @@ async function createAgentServer(params) {
     process.stderr.write(`  GET  /api/sessions                      \u2014 list sessions
 `);
     process.stderr.write(`  POST /api/sessions                      \u2014 create a new session
+`);
+    process.stderr.write(`  DEL  /api/sessions/:sessionId           \u2014 delete a session
 `);
     process.stderr.write(`  GET  /api/sessions/:sessionId/messages  \u2014 session messages
 `);
@@ -47585,6 +47696,9 @@ function createServerSessionAdapter(params) {
     get isStreaming() {
       return params.session.isStreaming;
     },
+    get errorMessage() {
+      return params.session.errorMessage;
+    },
     get model() {
       return params.session.model;
     },
@@ -47922,7 +48036,7 @@ async function main() {
     process.env.PI_SKIP_VERSION_CHECK = "1";
     settingsManager.setQuietStartup(true);
     settingsManager.setCollapseChangelog(true);
-    settingsManager.setLastChangelogVersion(version2);
+    settingsManager.setLastChangelogVersion(pi.VERSION || version2);
   }
   renderStartupSplash(version2);
   const spinner = createSpinner("Loading agent...");