skopix 2.0.0 → 2.0.1

package/cli/commands/agent.js

@@ -220,7 +220,7 @@ export async function agentCommand(options) {
 
     try {
       const { chromium } = await import('playwright');
-      const sessionDir = path.join(os.homedir(), '.skopix', 'sessions', runId);
+      const sessionDir = path.join(os.homedir(), '.skopix', runId);
       await fs.ensureDir(sessionDir);
 
       send({ type: 'stdout', text: '' });

package/cli/commands/dashboard.js

@@ -19,9 +19,9 @@ const SAVED_TESTS_FILE = '_saved.suite.yaml';
 export async function dashboardCommand(options) {
   const port = parseInt(options.port) || 9000;
   const host = options.host || process.env.SKOPIX_HOST || '127.0.0.1';
-  const reportsDir = path.resolve(options.dir || './skopix-reports');
+  const reportsDir = path.resolve(options.dir || path.join(os.homedir(), '.skopix'));
   const webRoot = path.resolve(__dirname, '..', '..', 'web');
-  const suitesDir = path.resolve(process.cwd());
+  const suitesDir = path.join(os.homedir(), '.skopix');
   const suiteRunsDir = path.join(reportsDir, '.suite-runs');
 
   await fs.ensureDir(reportsDir);
@@ -1889,6 +1889,13 @@ export async function dashboardCommand(options) {
         ws.send(JSON.stringify({ type: 'registered', agentId }));
         console.log(chalk.cyan('[agent]') + ' Connected: ' + agent.name + ' (' + agent.machine + ')');
         broadcastAgentList();
+
+        // Keepalive ping every 30s to prevent idle disconnection
+        const pingInterval = setInterval(() => {
+          if (ws.readyState !== 1) { clearInterval(pingInterval); return; }
+          try { ws.send(JSON.stringify({ type: 'ping' })); } catch { clearInterval(pingInterval); }
+        }, 30000);
+        ws.on('close', () => clearInterval(pingInterval));
         return;
       }
 
@@ -2110,55 +2117,64 @@ function testIdFromName(name) {
 
 // ─── SESSIONS ─────────────────────────────────────────────────────────────────
 async function listSessions(reportsDir) {
-  if (!await fs.pathExists(reportsDir)) return [];
-  const entries = await fs.readdir(reportsDir);
+  if (!await fs.pathExists(reportsDir)) { process.stderr.write('[sessions] reportsDir not found: ' + reportsDir + '\n'); return []; }
   const sessions = [];
-  for (const entry of entries) {
-    if (entry.startsWith('.')) continue;
-    const sessionPath = path.join(reportsDir, entry);
-    const stat = await fs.stat(sessionPath);
-    if (!stat.isDirectory()) continue;
-    const jsonPath = path.join(sessionPath, 'report.json');
-    if (await fs.pathExists(jsonPath)) {
-      try {
-        const data = await fs.readJson(jsonPath);
-        const status = data.goalAchieved ? 'passed' : data.stuck ? 'stuck' : 'failed';
-        // Read run attribution if present (team mode)
-        let runBy = null;
-        const runByPath = path.join(sessionPath, 'runBy.json');
-        if (await fs.pathExists(runByPath)) {
-          try { runBy = await fs.readJson(runByPath); } catch {}
-        }
-        sessions.push({
-          id: data.sessionId || entry, status,
-          url: data.url, goal: data.goal,
-          steps: data.steps?.length || 0,
-          issues: data.issues?.length || 0,
-          duration: formatDuration(data.duration || 0),
-          durationMs: data.duration || 0,
-          when: relativeTime(stat.mtime),
-          mtime: stat.mtime.toISOString(),
-          model: data.model, provider: data.provider,
-          runBy, // null in single-user mode or when no attribution recorded
-        });
-      } catch {}
+  // Check both reportsDir directly and reportsDir/sessions subfolder
+  const dirsToCheck = [reportsDir, path.join(reportsDir, 'sessions')];
+  for (const dir of dirsToCheck) {
+    if (!await fs.pathExists(dir)) continue;
+    const entries = await fs.readdir(dir);
+    process.stderr.write('[sessions] scanning ' + dir + ' entries: ' + entries.join(',') + '\n');
+    for (const entry of entries) {
+      if (entry.startsWith('.')) continue;
+      const sessionPath = path.join(dir, entry);
+      const stat = await fs.stat(sessionPath);
+      if (!stat.isDirectory()) continue;
+      const jsonPath = path.join(sessionPath, 'report.json');
+      if (await fs.pathExists(jsonPath)) {
+        try {
+          const data = await fs.readJson(jsonPath);
+          const status = data.goalAchieved ? 'passed' : data.stuck ? 'stuck' : 'failed';
+          let runBy = null;
+          const runByPath = path.join(sessionPath, 'runBy.json');
+          if (await fs.pathExists(runByPath)) {
+            try { runBy = await fs.readJson(runByPath); } catch {}
+          }
+          sessions.push({
+            id: data.sessionId || entry, status,
+            url: data.url, goal: data.goal,
+            steps: data.steps?.length || 0,
+            issues: data.issues?.length || 0,
+            duration: formatDuration(data.duration || 0),
+            durationMs: data.duration || 0,
+            when: relativeTime(stat.mtime),
+            mtime: stat.mtime.toISOString(),
+            model: data.model, provider: data.provider,
+            runBy,
+          });
+        } catch {}
+      }
     }
   }
   sessions.sort((a, b) => new Date(b.mtime) - new Date(a.mtime));
   return sessions;
 }
 async function getSession(reportsDir, id) {
-  const jsonPath = path.join(reportsDir, id, 'report.json');
-  if (!await fs.pathExists(jsonPath)) return null;
-  try {
-    const data = await fs.readJson(jsonPath);
-    // Attach runBy if present
-    const runByPath = path.join(reportsDir, id, 'runBy.json');
-    if (await fs.pathExists(runByPath)) {
-      try { data.runBy = await fs.readJson(runByPath); } catch {}
-    }
-    return data;
-  } catch { return null; }
+  // Check both reportsDir/id and reportsDir/sessions/id
+  const locations = [path.join(reportsDir, id), path.join(reportsDir, 'sessions', id)];
+  for (const sessionPath of locations) {
+    const jsonPath = path.join(sessionPath, 'report.json');
+    if (!await fs.pathExists(jsonPath)) continue;
+    try {
+      const data = await fs.readJson(jsonPath);
+      const runByPath = path.join(sessionPath, 'runBy.json');
+      if (await fs.pathExists(runByPath)) {
+        try { data.runBy = await fs.readJson(runByPath); } catch {}
+      }
+      return data;
+    } catch {}
+  }
+  return null;
 }
 function computeStats(sessions) {
   const total = sessions.length;
@@ -2173,7 +2189,7 @@ function computeStats(sessions) {
   return { total, passed, failed, stuck, passRate, totalIssues, avgDuration: formatDuration(avgMs), avgDurationMs: avgMs, thisWeek };
 }
 async function getConfig() {
-  const envPath = path.resolve(process.cwd(), '.skopix.env');
+  const envPath = path.join(os.homedir(), '.skopix.env');
   if (!await fs.pathExists(envPath)) return [];
   const content = await fs.readFile(envPath, 'utf-8');
   const config = [];
@@ -3388,6 +3404,7 @@ async function deleteAllSuiteRuns(suiteRunsDir) {
 async function closeRemoteIssue(issue) {
   const axios = (await import('axios')).default;
   const dotenv = (await import('dotenv')).default;
+  dotenv.config({ path: path.join(os.homedir(), '.skopix.env') });
   dotenv.config({ path: path.resolve(process.cwd(), '.skopix.env') });
   dotenv.config();
 
@@ -3470,6 +3487,7 @@ async function resolveUserSecretsEnv(userId, teamMode) {
 async function syncIssuesStatus() {
   const axios = (await import('axios')).default;
   const dotenv = (await import('dotenv')).default;
+  dotenv.config({ path: path.join(os.homedir(), '.skopix.env') });
   dotenv.config({ path: path.resolve(process.cwd(), '.skopix.env') });
   dotenv.config();
 

package/core/llm.js

@@ -1,9 +1,10 @@
 import dotenv from 'dotenv';
 import path from 'path';
+import os from 'os';
 import axios from 'axios';
 
-const envPath = path.resolve(process.cwd(), '.skopix.env');
-dotenv.config({ path: envPath });
+// Always load from home directory
+dotenv.config({ path: path.join(os.homedir(), '.skopix.env') });
 dotenv.config();
 
 export class LLMRouter {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skopix",
-  "version": "2.0.0",
+  "version": "2.0.1",
   "description": "Browser-based QA tool — record tests by using your app, replay them deterministically, generate Playwright code automatically",
   "main": "cli/index.js",
   "bin": {