pi-web 0.13.1 → 0.13.2

package/build/server/rpc.js

@@ -6,9 +6,8 @@ export class RpcSession {
     opts;
     constructor(opts) {
         this.opts = opts;
-        const parts = opts.piCmd.split(/\s+/);
-        const cmd = parts[0];
-        const args = [...parts.slice(1), '--mode', 'rpc'];
+        const cmd = opts.piCmd.command;
+        const args = [...opts.piCmd.args, '--mode', 'rpc'];
         this.proc = spawn(cmd, args, {
             cwd: opts.cwd,
             stdio: ['pipe', 'pipe', 'pipe'],

package/build/server/server.js

@@ -42,8 +42,8 @@ function parseAgent(value) {
 }
 function getAgentCommand(agent) {
     return agent === 'omp'
-        ? 'npx -y @oh-my-pi/pi-coding-agent@latest'
-        : 'npx -y @mariozechner/pi-coding-agent@latest';
+        ? { command: 'npx', args: ['-y', '@oh-my-pi/pi-coding-agent@latest'] }
+        : { command: 'npx', args: ['-y', '@mariozechner/pi-coding-agent@latest'] };
 }
 const AGENT = parseAgent(getArg('agent'));
 const PORT = parseInt(getArg('port') || '8192', 10);
@@ -59,6 +59,7 @@ const distDir = distDirCandidates.find((candidate) => existsSync(join(candidate,
 const htmlPath = join(distDir, 'index.html');
 const htmlCache = isDev || !existsSync(htmlPath) ? null : readFileSync(htmlPath, 'utf-8');
 const HOME_DIR = resolve(homedir() || '/');
+const SESSION_ROOT = resolve(join(HOME_DIR, AGENT === 'omp' ? '.omp' : '.pi', 'agent', 'sessions'));
 function isWithinRoot(path, root) {
     const rel = relative(root, path);
     return rel === '' || (!rel.startsWith('..') && !isAbsolute(rel));
@@ -103,6 +104,22 @@ function serveFile(filePath, res) {
     res.writeHead(200, { 'Content-Type': contentTypes[ext] || 'application/octet-stream' });
     createReadStream(filePath).pipe(res);
 }
+function logServerError(context, error) {
+    console.error(`[pi-web] ${context}`, error);
+}
+function respondJson(res, statusCode, payload) {
+    res.writeHead(statusCode, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify(payload));
+}
+function isValidSessionFilename(filename) {
+    return basename(filename) === filename && filename.endsWith('.jsonl');
+}
+function resolveSessionPath(cwd, filename) {
+    if (!isValidSessionFilename(filename))
+        return null;
+    const resolved = resolve(getSessionFilePath(cwd, filename, AGENT));
+    return isWithinRoot(resolved, SESSION_ROOT) ? resolved : null;
+}
 const server = createServer((req, res) => {
     if (req.url === '/' || req.url === '/index.html') {
         if (!existsSync(htmlPath)) {
@@ -123,12 +140,11 @@ const server = createServer((req, res) => {
                 ...session,
                 ...getSessionRuntimeStatus(session.cwd, session.file),
             }));
-            res.writeHead(200, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify(sessionsWithRuntime));
+            respondJson(res, 200, sessionsWithRuntime);
         })
             .catch((err) => {
-            res.writeHead(500, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ error: String(err) }));
+            logServerError('failed to list sessions', err);
+            respondJson(res, 500, { error: 'failed to list sessions' });
         });
         return;
     }
@@ -137,12 +153,11 @@ const server = createServer((req, res) => {
         const cwd = url.searchParams.get('cwd');
         listFolders(cwd)
             .then((data) => {
-            res.writeHead(200, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify(data));
+            respondJson(res, 200, data);
         })
             .catch((err) => {
-            res.writeHead(500, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ error: String(err) }));
+            logServerError('failed to list folders', err);
+            respondJson(res, 500, { error: 'failed to list folders' });
         });
         return;
     }
@@ -151,31 +166,36 @@ const server = createServer((req, res) => {
         const cwd = url.searchParams.get('cwd');
         const filename = url.searchParams.get('filename');
         if (!cwd || !filename) {
-            res.writeHead(400, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ error: 'cwd and filename parameters required' }));
+            respondJson(res, 400, { error: 'cwd and filename parameters required' });
+            return;
+        }
+        const file = resolveSessionPath(cwd, filename);
+        if (!file) {
+            respondJson(res, 400, { error: 'invalid session path' });
             return;
         }
-        const file = getSessionFilePath(cwd, filename, AGENT);
         if (req.method === 'DELETE') {
             try {
+                const managed = findManagedSessionByFile(cwd, filename);
+                if (managed) {
+                    closeManagedSession(managed);
+                }
                 unlinkSync(file);
-                res.writeHead(200, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ ok: true }));
+                respondJson(res, 200, { ok: true });
             }
             catch (err) {
-                res.writeHead(500, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ error: String(err) }));
+                logServerError(`failed to delete session ${file}`, err);
+                respondJson(res, 500, { error: 'failed to delete session' });
             }
             return;
         }
         readSessionMessages(file)
             .then((messages) => {
-            res.writeHead(200, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify(messages));
+            respondJson(res, 200, messages);
         })
             .catch((err) => {
-            res.writeHead(500, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ error: String(err) }));
+            logServerError(`failed to read session ${file}`, err);
+            respondJson(res, 500, { error: 'failed to read session' });
         });
         return;
     }
@@ -184,8 +204,8 @@ const server = createServer((req, res) => {
         const safePath = normalize(url.pathname)
             .replace(/^(\.\.[/\\])+/, '')
             .replace(/^[/\\]+/, '');
-        const filePath = join(distDir, safePath);
-        if (filePath.startsWith(distDir) && existsSync(filePath) && statSync(filePath).isFile()) {
+        const filePath = resolve(join(distDir, safePath));
+        if (isWithinRoot(filePath, distDir) && existsSync(filePath) && statSync(filePath).isFile()) {
             serveFile(filePath, res);
             return;
         }
@@ -266,6 +286,19 @@ function closeManagedSession(managed) {
     unregisterManagedSession(managed);
     managed.rpc.kill();
 }
+function findManagedSessionByFile(cwd, sessionFile) {
+    const key = buildSessionKey(resolve(cwd), basename(sessionFile));
+    const direct = rpcSessions.get(key);
+    if (direct && !direct.isClosing)
+        return direct;
+    for (const managed of rpcSessions.values()) {
+        if (managed.isClosing)
+            continue;
+        if (managed.cwd === resolve(cwd) && managed.keys.has(key))
+            return managed;
+    }
+    return null;
+}
 function cleanupIfIdle(managed) {
     if (managed.isClosing)
         return;
@@ -363,6 +396,7 @@ function createManagedSession(cwd, sessionFile, initialKey) {
         onError: (error) => {
             if (!managed)
                 return;
+            logServerError(`rpc session error (${managed.cwd}${managed.sessionFile ? `/${managed.sessionFile}` : ''})`, error);
             broadcast(managed, { type: 'error', message: error });
         },
         onExit: (code) => {

package/build/server/sessions.js

@@ -70,7 +70,7 @@ export async function readSessionMessages(filePath) {
     try {
         for await (const line of rl) {
             const trimmed = line.trim();
-            if (!trimmed || !trimmed.startsWith('{"type":"message"'))
+            if (!trimmed)
                 continue;
             try {
                 const entry = JSON.parse(trimmed);
@@ -140,36 +140,28 @@ async function readSessionHeader(filePath) {
             const trimmed = line.trim();
             if (!trimmed)
                 continue;
-            if (!header) {
-                try {
-                    const parsed = JSON.parse(trimmed);
-                    if (parsed.type === 'session') {
-                        header = parsed;
-                        continue;
-                    }
+            try {
+                const parsed = JSON.parse(trimmed);
+                if (!header && parsed.type === 'session') {
+                    header = parsed;
+                    continue;
                 }
-                catch { }
-            }
-            if (trimmed.startsWith('{"type":"message"')) {
+                if (parsed.type !== 'message')
+                    continue;
                 messageCount++;
-                if (!firstPrompt && trimmed.includes('"role":"user"')) {
-                    try {
-                        const msg = JSON.parse(trimmed);
-                        if (msg.message?.role === 'user') {
-                            const content = msg.message.content;
-                            if (typeof content === 'string') {
-                                firstPrompt = content.slice(0, 120);
-                            }
-                            else if (Array.isArray(content)) {
-                                const text = content.find((c) => c.type === 'text');
-                                if (text?.text)
-                                    firstPrompt = text.text.slice(0, 120);
-                            }
-                        }
+                if (!firstPrompt && parsed.message?.role === 'user') {
+                    const content = parsed.message.content;
+                    if (typeof content === 'string') {
+                        firstPrompt = content.slice(0, 120);
+                    }
+                    else if (Array.isArray(content)) {
+                        const text = content.find((c) => c.type === 'text');
+                        if (text?.text)
+                            firstPrompt = text.text.slice(0, 120);
                     }
-                    catch { }
                 }
             }
+            catch { }
         }
     }
     finally {