@docyrus/docyrus 0.0.23 → 0.0.25

package/server-loader.js

@@ -3092,6 +3092,85 @@ async function waitForIdle(session, timeoutMs = 3e4) {
     }
   });
 }
+function convertSessionEntriesToUIMessages(entries) {
+  const messages = [];
+  const toolResults = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const rec = entry;
+    if (rec.type !== "message") {
+      continue;
+    }
+    const msg = rec.message;
+    if (!msg || msg.role !== "toolResult") {
+      continue;
+    }
+    const toolCallId = msg.toolCallId;
+    if (toolCallId) {
+      const content = msg.content;
+      const textParts = Array.isArray(content) ? content.filter((b) => b.type === "text").map((b) => b.text).join("\n") : typeof content === "string" ? content : "";
+      toolResults.set(toolCallId, {
+        output: textParts,
+        isError: msg.isError ?? false
+      });
+    }
+  }
+  for (const entry of entries) {
+    const rec = entry;
+    if (rec.type !== "message") {
+      continue;
+    }
+    const msg = rec.message;
+    if (!msg) {
+      continue;
+    }
+    const entryId = rec.id ?? `entry_${messages.length}`;
+    if (msg.role === "user") {
+      const content = msg.content;
+      let text = "";
+      if (typeof content === "string") {
+        text = content;
+      } else if (Array.isArray(content)) {
+        text = content.filter((b) => b.type === "text").map((b) => b.text).join("\n");
+      }
+      if (text) {
+        messages.push({ id: entryId, role: "user", parts: [{ type: "text", text }] });
+      }
+      continue;
+    }
+    if (msg.role === "assistant") {
+      const content = msg.content;
+      if (!Array.isArray(content)) {
+        continue;
+      }
+      const parts = [];
+      for (const block of content) {
+        if (block.type === "text" && typeof block.text === "string") {
+          parts.push({ type: "text", text: block.text });
+        } else if (block.type === "thinking" && typeof block.thinking === "string") {
+          parts.push({ type: "reasoning", text: block.thinking, state: "complete" });
+        } else if (block.type === "toolCall") {
+          const toolCallId = block.id;
+          const toolName = block.name;
+          const input = block.arguments ?? {};
+          const result = toolResults.get(toolCallId);
+          parts.push({
+            type: "dynamic-tool",
+            toolCallId,
+            toolName,
+            input,
+            state: result ? result.isError ? "output-error" : "output-available" : "input-available",
+            ...result && !result.isError ? { output: result.output } : {},
+            ...result && result.isError ? { errorText: String(result.output) } : {}
+          });
+        }
+      }
+      if (parts.length > 0) {
+        messages.push({ id: entryId, role: "assistant", parts });
+      }
+    }
+  }
+  return messages;
+}
 var FS_IGNORE = /* @__PURE__ */ new Set([
   "node_modules",
   ".git",
@@ -3135,13 +3214,19 @@ async function buildTree(params) {
   entries.sort((a, b) => {
     const aIsDir = a.isDirectory();
     const bIsDir = b.isDirectory();
-    if (aIsDir !== bIsDir) return aIsDir ? -1 : 1;
+    if (aIsDir !== bIsDir) {
+      return aIsDir ? -1 : 1;
+    }
     return a.name.localeCompare(b.name);
   });
   const result = [];
   for (const entry of entries) {
-    if (counter.value >= maxFiles) break;
-    if (ignore.has(entry.name)) continue;
+    if (counter.value >= maxFiles) {
+      break;
+    }
+    if (ignore.has(entry.name)) {
+      continue;
+    }
     const fullPath = (0, import_node_path2.join)(dir, entry.name);
     const relativePath = (0, import_node_path2.relative)(cwd, fullPath);
     if (entry.isDirectory()) {
@@ -3164,7 +3249,9 @@ async function buildTree(params) {
 }
 async function walkFiles(params) {
   const { dir, cwd, pattern, ignore, maxResults, results } = params;
-  if (results.length >= maxResults) return;
+  if (results.length >= maxResults) {
+    return;
+  }
   let entries;
   try {
     entries = await (0, import_promises2.readdir)(dir, { withFileTypes: true });
@@ -3172,8 +3259,12 @@ async function walkFiles(params) {
     return;
   }
   for (const entry of entries) {
-    if (results.length >= maxResults) break;
-    if (ignore.has(entry.name)) continue;
+    if (results.length >= maxResults) {
+      break;
+    }
+    if (ignore.has(entry.name)) {
+      continue;
+    }
     const fullPath = (0, import_node_path2.join)(dir, entry.name);
     const relativePath = (0, import_node_path2.relative)(cwd, fullPath);
     if (entry.isDirectory()) {
@@ -3184,7 +3275,7 @@ async function walkFiles(params) {
   }
 }
 async function createAgentServer(params) {
-  const { port, sessionManager, modelRegistry, context, onResumeSession } = params;
+  const { port, sessionManager, modelRegistry, context, onCreateSession, onResumeSession } = params;
   let activeSession = params.session;
   const app = new Hono2();
   app.use("/*", cors({ origin: "*" }));
@@ -3279,6 +3370,31 @@ async function createAgentServer(params) {
       return c.json({ error: message }, 500);
     }
   });
+  app.post("/api/sessions", async (c) => {
+    try {
+      if (activeSession.isStreaming) {
+        await activeSession.abort();
+        await waitForIdle(activeSession);
+      }
+      activeSession = await onCreateSession();
+      const sessionId = activeSession.id?.trim();
+      if (!sessionId) {
+        return c.json({ error: "Created session is missing an id" }, 500);
+      }
+      const sessions = await sessionManager.list();
+      const match2 = sessions.find((session) => session.id === sessionId);
+      return c.json({
+        ok: true,
+        sessionId,
+        sessionName: match2?.name ?? null,
+        cwd: match2?.cwd ?? context.cwd,
+        model: activeSession.model ? { provider: activeSession.model.provider, id: activeSession.model.id } : null
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return c.json({ error: message }, 500);
+    }
+  });
   app.get("/api/sessions/:sessionId/messages", async (c) => {
     const sessionId = c.req.param("sessionId");
     try {
@@ -3289,14 +3405,15 @@ async function createAgentServer(params) {
       }
       const opened = sessionManager.open(match2.path);
       const sessionContext = opened.buildSessionContext();
-      const entries = opened.getBranch();
+      const rawEntries = opened.getBranch();
+      const messages = convertSessionEntriesToUIMessages(rawEntries);
       return c.json({
         sessionId: opened.getSessionId(),
         sessionName: opened.getSessionName() ?? null,
         cwd: opened.getCwd(),
         model: sessionContext.model ?? null,
         thinkingLevel: sessionContext.thinkingLevel ?? null,
-        entries
+        messages
       });
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
@@ -3466,6 +3583,42 @@ async function createAgentServer(params) {
       return c.json({ error: message }, status);
     }
   });
+  const CLI_EXEC = process.env.DOCYRUS_CLI_EXECUTABLE || process.execPath;
+  const CLI_ENTRY = process.env.DOCYRUS_CLI_ENTRY || (0, import_node_path2.resolve)(process.argv[1] ? (0, import_node_path2.join)(process.argv[1], "..") : __dirname, "main.js");
+  const CLI_SCOPE = process.env.DOCYRUS_CLI_SCOPE;
+  const CLI_TIMEOUT_MS = 3e4;
+  function runCliCommand(args) {
+    return new Promise((resolveResult) => {
+      const scopeArgs = CLI_SCOPE ? ["--scope", CLI_SCOPE] : [];
+      const proc = (0, import_node_child_process.spawn)(CLI_EXEC, [CLI_ENTRY, ...scopeArgs, ...args, "--json"], {
+        cwd: context.cwd,
+        stdio: ["ignore", "pipe", "pipe"],
+        timeout: CLI_TIMEOUT_MS
+      });
+      let stdout = "";
+      let stderr = "";
+      proc.stdout?.on("data", (chunk) => {
+        stdout += chunk.toString();
+      });
+      proc.stderr?.on("data", (chunk) => {
+        stderr += chunk.toString();
+      });
+      proc.on("close", (code) => {
+        if (code !== 0) {
+          resolveResult({ ok: false, error: stderr.trim() || `exit code ${code}` });
+          return;
+        }
+        try {
+          resolveResult({ ok: true, data: JSON.parse(stdout) });
+        } catch {
+          resolveResult({ ok: true, data: stdout.trim() });
+        }
+      });
+      proc.on("error", (err) => {
+        resolveResult({ ok: false, error: err.message });
+      });
+    });
+  }
   let devProcess = null;
   let devUrl = null;
   const DEV_URL_PATTERN = /https?:\/\/(?:localhost|127\.0\.0\.1):\d+/;
@@ -3479,13 +3632,104 @@ async function createAgentServer(params) {
       return null;
     }
   }
+  async function detectDevPort(cwd) {
+    try {
+      const pkg = JSON.parse(await (0, import_promises2.readFile)((0, import_node_path2.join)(cwd, "package.json"), "utf-8"));
+      const devScript = pkg.scripts?.dev;
+      if (devScript) {
+        const portFlag = devScript.match(/--port\s+(\d+)/);
+        if (portFlag) {
+          return Number(portFlag[1]);
+        }
+        const dashP = devScript.match(/(?:^|\s)-p\s+(\d+)/);
+        if (dashP) {
+          return Number(dashP[1]);
+        }
+      }
+    } catch {
+    }
+    for (const name of ["vite.config.ts", "vite.config.mts", "vite.config.js"]) {
+      try {
+        const content = await (0, import_promises2.readFile)((0, import_node_path2.join)(cwd, name), "utf-8");
+        const portMatch = content.match(/port\s*:\s*(\d+)/);
+        if (portMatch) {
+          return Number(portMatch[1]);
+        }
+      } catch {
+      }
+    }
+    for (const name of ["next.config.ts", "next.config.mts", "next.config.js", "next.config.mjs"]) {
+      try {
+        await (0, import_promises2.stat)((0, import_node_path2.join)(cwd, name));
+        return 3e3;
+      } catch {
+      }
+    }
+    try {
+      await (0, import_promises2.stat)((0, import_node_path2.join)(cwd, "angular.json"));
+      return 4200;
+    } catch {
+    }
+    for (const name of ["nuxt.config.ts", "nuxt.config.js"]) {
+      try {
+        await (0, import_promises2.stat)((0, import_node_path2.join)(cwd, name));
+        return 3e3;
+      } catch {
+      }
+    }
+    return null;
+  }
+  let cachedProjectInfo = null;
+  async function getProjectInfo() {
+    if (cachedProjectInfo) {
+      return cachedProjectInfo;
+    }
+    const cwd = context.cwd;
+    let repo = null;
+    let packageName = null;
+    let packageVersion = null;
+    try {
+      repo = await new Promise((res, rej) => {
+        (0, import_node_child_process.execFile)("git", ["remote", "get-url", "origin"], { cwd }, (err, stdout) => {
+          if (err) {
+            return rej(err);
+          }
+          const url = stdout.trim();
+          const match2 = url.match(/\/([^/]+?)(?:\.git)?$/);
+          res(match2 ? match2[1] : url);
+        });
+      });
+    } catch {
+    }
+    try {
+      const pkg = JSON.parse(await (0, import_promises2.readFile)((0, import_node_path2.join)(cwd, "package.json"), "utf-8"));
+      packageName = pkg.name ?? null;
+      packageVersion = pkg.version ?? null;
+    } catch {
+    }
+    cachedProjectInfo = {
+      path: cwd,
+      folder: (0, import_node_path2.basename)(cwd),
+      repo,
+      packageName,
+      packageVersion
+    };
+    return cachedProjectInfo;
+  }
   app.get("/api/env/status", async (c) => {
+    const [authResult, project] = await Promise.all([
+      runCliCommand(["auth", "who"]),
+      getProjectInfo()
+    ]);
+    const env = authResult.ok ? authResult.data : null;
     if (devProcess && devProcess.exitCode === null && devUrl) {
       const httpStatus = await probeUrl(devUrl);
       return c.json({
         status: httpStatus !== null ? "running" : "starting",
         url: devUrl,
         managed: true,
+        project,
+        env,
         ...httpStatus !== null ? { httpStatus } : {}
       });
     }
@@ -3494,17 +3738,33 @@ async function createAgentServer(params) {
       devProcess = null;
       const stoppedUrl = devUrl;
       devUrl = null;
-      return c.json({ status: "stopped", url: stoppedUrl, exitCode, managed: true });
+      return c.json({ status: "stopped", url: stoppedUrl, exitCode, managed: true, project, env });
     }
-    const commonPorts = [5173, 5174, 3e3, 3001, 4321, 8080, 8e3];
-    for (const devPort of commonPorts) {
-      const candidate = `http://localhost:${devPort}`;
-      const httpStatus = await probeUrl(candidate);
-      if (httpStatus !== null) {
-        return c.json({ status: "running", url: candidate, httpStatus, managed: false });
+    const explicitUrl = c.req.query("url");
+    const explicitPort = c.req.query("port");
+    let probeTarget = null;
+    if (explicitUrl) {
+      probeTarget = explicitUrl;
+    } else if (explicitPort) {
+      probeTarget = `http://localhost:${explicitPort}`;
+    } else {
+      const detected = await detectDevPort(context.cwd);
+      if (detected) {
+        probeTarget = `http://localhost:${detected}`;
       }
     }
-    return c.json({ status: "stopped", url: null, managed: false });
+    if (probeTarget) {
+      const httpStatus = await probeUrl(probeTarget);
+      return c.json({
+        status: httpStatus !== null ? "running" : "stopped",
+        url: probeTarget,
+        httpStatus: httpStatus ?? void 0,
+        managed: false,
+        project,
+        env
+      });
+    }
+    return c.json({ status: "stopped", url: null, managed: false, project, env });
   });
   app.post("/api/env/serve", (c) => {
     if (devProcess && devProcess.exitCode === null) {
@@ -3521,7 +3781,9 @@ async function createAgentServer(params) {
       let stderr = "";
       let resolved = false;
       function settle(response) {
-        if (resolved) return;
+        if (resolved) {
+          return;
+        }
         resolved = true;
         resolveResponse(response);
       }
@@ -3562,13 +3824,103 @@ async function createAgentServer(params) {
     devUrl = null;
     return c.json({ status: "stopped", url: stoppedUrl, pid });
   });
+  const BOOLEAN_CLI_FLAGS = /* @__PURE__ */ new Set(["json", "verbose", "global", "noAuth", "expand", "i"]);
+  function buildCliArgs(pathSegments, query, body) {
+    const args = [...pathSegments, "--json"];
+    for (const [key, value] of Object.entries(query)) {
+      if (key === "json") {
+        continue;
+      }
+      const flag = key.length === 1 ? `-${key}` : `--${key}`;
+      if (BOOLEAN_CLI_FLAGS.has(key) || value === "" || value === "true") {
+        args.push(flag);
+      } else {
+        args.push(flag, value);
+      }
+    }
+    if (body) {
+      if (body.data !== void 0) {
+        args.push("--data", typeof body.data === "string" ? body.data : JSON.stringify(body.data));
+      }
+      if (typeof body.fromFile === "string") {
+        args.push("--from-file", body.fromFile);
+      }
+      for (const [key, value] of Object.entries(body)) {
+        if (key === "data" || key === "fromFile") {
+          continue;
+        }
+        const flag = key.length === 1 ? `-${key}` : `--${key}`;
+        if (typeof value === "boolean") {
+          if (value) {
+            args.push(flag);
+          }
+        } else if (value !== void 0 && value !== null) {
+          args.push(flag, String(value));
+        }
+      }
+    }
+    return args;
+  }
+  app.all("/api/cli/*", async (c) => {
+    const pathSegments = c.req.path.replace(/^\/api\/cli\/?/, "").split("/").filter(Boolean);
+    if (pathSegments.length === 0) {
+      return c.json({ error: "No command specified. Usage: /api/cli/<command>/[subcommand]/[args...]" }, 400);
+    }
+    const query = {};
+    for (const [key, value] of Object.entries(c.req.query())) {
+      if (typeof value === "string") {
+        query[key] = value;
+      }
+    }
+    let body;
+    if (c.req.method === "POST" || c.req.method === "PUT") {
+      try {
+        body = await c.req.json();
+      } catch {
+      }
+    }
+    const cliArgs = buildCliArgs(pathSegments, query, body);
+    return new Promise((resolveResponse) => {
+      const scopeArgs = CLI_SCOPE ? ["--scope", CLI_SCOPE] : [];
+      const proc = (0, import_node_child_process.spawn)(CLI_EXEC, [CLI_ENTRY, ...scopeArgs, ...cliArgs], {
+        cwd: context.cwd,
+        stdio: ["ignore", "pipe", "pipe"],
+        timeout: CLI_TIMEOUT_MS
+      });
+      let stdout = "";
+      let stderr = "";
+      proc.stdout?.on("data", (chunk) => {
+        stdout += chunk.toString();
+      });
+      proc.stderr?.on("data", (chunk) => {
+        stderr += chunk.toString();
+      });
+      proc.on("close", (code) => {
+        if (code !== 0) {
+          resolveResponse(c.json({
+            error: stderr.trim() || `Command exited with code ${code}`,
+            command: `docyrus ${cliArgs.join(" ")}`,
+            exitCode: code
+          }, 500));
+          return;
+        }
+        try {
+          const parsed = JSON.parse(stdout);
+          resolveResponse(c.json(parsed));
+        } catch {
+          resolveResponse(c.json({ output: stdout.trim(), command: `docyrus ${cliArgs.join(" ")}` }));
+        }
+      });
+      proc.on("error", (err) => {
+        resolveResponse(c.json({ error: err.message, command: `docyrus ${cliArgs.join(" ")}` }, 500));
+      });
+    });
+  });
   const { serve: serve2 } = await Promise.resolve().then(() => (init_dist(), dist_exports));
-  serve2({
-    fetch: app.fetch,
-    port
-  }, (info) => {
+  const MAX_PORT_RETRIES = 10;
+  function printBanner(actualPort) {
     process.stderr.write(`
-  Agent server listening on http://localhost:${info.port}
+  Agent server listening on http://localhost:${actualPort}
 
 `);
     process.stderr.write(`  POST /api/chat                          \u2014 send chat messages (SSE UIMessage stream)
@@ -3578,6 +3930,8 @@ async function createAgentServer(params) {
     process.stderr.write(`  GET  /api/status                        \u2014 session status
 `);
     process.stderr.write(`  GET  /api/sessions                      \u2014 list sessions
+`);
+    process.stderr.write(`  POST /api/sessions                      \u2014 create a new session
 `);
     process.stderr.write(`  GET  /api/sessions/:sessionId/messages  \u2014 session messages
 `);
@@ -3606,9 +3960,37 @@ async function createAgentServer(params) {
     process.stderr.write(`  POST /api/env/serve                     \u2014 start dev server (pnpm dev)
 `);
     process.stderr.write(`  POST /api/env/stop                      \u2014 stop dev server
+`);
+    process.stderr.write(`  *    /api/cli/**                        \u2014 proxy any docyrus CLI command
 
 `);
-  });
+  }
+  for (let attempt = 0; attempt < MAX_PORT_RETRIES; attempt++) {
+    const candidatePort = port + attempt;
+    try {
+      await new Promise((resolveStart, rejectStart) => {
+        const server = serve2({ fetch: app.fetch, port: candidatePort }, () => {
+          printBanner(candidatePort);
+          resolveStart();
+        });
+        server.on("error", (err) => {
+          if (err.code === "EADDRINUSE") {
+            process.stderr.write(`  Port ${candidatePort} in use, trying ${candidatePort + 1}...
+`);
+            rejectStart(err);
+          } else {
+            throw err;
+          }
+        });
+      });
+      return;
+    } catch (err) {
+      const isAddrInUse = err instanceof Error && "code" in err && err.code === "EADDRINUSE";
+      if (!isAddrInUse || attempt === MAX_PORT_RETRIES - 1) {
+        throw new Error(`All ports ${port}\u2013${port + MAX_PORT_RETRIES - 1} are in use`);
+      }
+    }
+  }
 }
 
 // src/server/server-loader.ts
@@ -3808,6 +4190,21 @@ Or create ${modelsJsonPath}`
       sessionDir: request.sessionDir ?? null,
       thinkingLevel: request.thinking ?? null
     },
+    onCreateSession: async () => {
+      const { session: freshSession } = await pi.createAgentSession({
+        cwd,
+        agentDir,
+        authStorage,
+        modelRegistry,
+        resourceLoader,
+        settingsManager,
+        sessionManager,
+        tools: buildTools(request.profile, cwd, pi),
+        model: requestedModel,
+        thinkingLevel: request.thinking
+      });
+      return freshSession;
+    },
     onResumeSession: async (sessionId) => {
       const sessions = await pi.SessionManager.list(cwd, request.sessionDir);
       const match2 = sessions.find((s) => s.id === sessionId);