@slycode/slycode 0.2.3 → 0.2.5

package/dist/web/src/lib/paths.ts

@@ -64,3 +64,24 @@ export function getProjectPath(projectId: string, projectPath?: string): string
   if (projectPath) return projectPath;
   return path.join(getProjectsDir(), projectId.replace(/-/g, '_'));
 }
+
+/**
+ * Get the bridge URL for server-side HTTP calls.
+ *
+ * Single source of truth. All server-side code that talks to the bridge
+ * should call this instead of reading process.env.BRIDGE_URL directly.
+ *
+ * In production, startup scripts (sly-start.sh, systemd, slycode CLI)
+ * set BRIDGE_URL in the shell environment before starting the web server.
+ *
+ * In dev, BRIDGE_URL is NOT set in the shell — the bridge runs on its
+ * hardcoded default (3004). But the parent .env has BRIDGE_URL=...7592
+ * for prod, and various .env loaders can leak that into process.env.
+ * So in dev we ignore process.env.BRIDGE_URL and use the known default.
+ */
+export function getBridgeUrl(): string {
+  if (process.env.NODE_ENV === 'production' && process.env.BRIDGE_URL) {
+    return process.env.BRIDGE_URL;
+  }
+  return 'http://127.0.0.1:3004';
+}

package/dist/web/src/lib/registry.ts

@@ -29,6 +29,7 @@ import {
 } from './asset-scanner';
 import { getStoreAssets } from './store-scanner';
 import { calculateHealthFromAssets } from './health-score';
+import { getBridgeUrl } from './paths';
 
 // Path to the registry file
 // Resolution: SLYCODE_HOME → derive from cwd
@@ -306,7 +307,7 @@ export async function loadDashboardData(): Promise<DashboardData> {
   }, 0);
 
   // Fetch bridge session counts (best-effort, don't fail if bridge is down)
-  const bridgeUrl = process.env.BRIDGE_URL || 'http://127.0.0.1:7592';
+  const bridgeUrl = getBridgeUrl();
   try {
     const resp = await fetch(`${bridgeUrl}/stats`, { signal: AbortSignal.timeout(2000) });
     if (resp.ok) {

package/dist/web/src/lib/scheduler.ts

@@ -12,23 +12,17 @@
 import { promises as fs } from 'fs';
 import { readFileSync } from 'fs';
 import path from 'path';
+import os from 'os';
 import { Cron } from 'croner';
 import type { KanbanCard, KanbanBoard, AutomationConfig } from './types';
 import { loadRegistry } from './registry';
 import { cronToHumanReadable } from './cron-utils';
-import { getSlycodeRoot } from './paths';
+import { getSlycodeRoot, getBridgeUrl } from './paths';
 
 /**
  * Load env vars from the project root .env file if not already set.
  * Next.js only auto-loads .env from web/, but our config lives in the parent.
- *
- * BRIDGE_URL and BRIDGE_PORT are excluded — these are port-dependent and differ
- * between dev (3004) and prod (7592). In prod, sly-start.sh sets BRIDGE_URL in
- * the shell environment. In dev, we fall back to localhost:3004. Loading them
- * from .env would route dev scheduler requests to the prod bridge.
  */
-const SKIP_ENV_KEYS = new Set(['BRIDGE_URL', 'BRIDGE_PORT']);
-
 function loadParentEnv() {
   try {
     const envPath = path.join(getSlycodeRoot(), '.env');
@@ -40,7 +34,6 @@ function loadParentEnv() {
       if (eqIdx < 0) continue;
       const key = trimmed.slice(0, eqIdx).trim();
       const value = trimmed.slice(eqIdx + 1).trim();
-      if (SKIP_ENV_KEYS.has(key)) continue;
       if (!process.env[key]) {
         process.env[key] = value;
       }
@@ -50,12 +43,15 @@ function loadParentEnv() {
 
 loadParentEnv();
 
-const BRIDGE_URL = process.env.BRIDGE_URL || 'http://localhost:3004';
+const BRIDGE_URL = getBridgeUrl();
 const CONFIGURED_TIMEZONE = process.env.TZ || 'UTC';
 const CHECK_INTERVAL_MS = 30_000; // Check every 30 seconds
 const GRACE_WINDOW_MS = 60_000;   // Only catch up ticks missed within this window
 const FETCH_TIMEOUT_MS = 10_000;  // Timeout for bridge HTTP calls
 
+const AUTOMATION_LOG_PATH = path.join(os.homedir(), '.slycode', 'logs', 'automation.log');
+const AUTOMATION_LOG_MAX_BYTES = 1_000_000; // 1MB cap
+
 // Fresh session path: simple liveness check after startup
 const LIVENESS_CHECK_MS = 20_000; // Wait 20s then check if session is alive
 
@@ -77,6 +73,59 @@ async function fetchWithTimeout(url: string, opts?: RequestInit): Promise<Respon
   }
 }
 
+/**
+ * Automation run log entry — one per automation execution.
+ */
+interface AutomationLogEntry {
+  timestamp: string;
+  cardId: string;
+  cardTitle: string;
+  projectId: string;
+  trigger: 'scheduled' | 'manual';
+  provider: string;
+  sessionName: string;
+  fresh: boolean;
+  bridgeRequest: { status: number; resumed?: boolean; pid?: number; error?: string } | null;
+  livenessCheck: { type: string; result: string; delayMs?: number; exitCode?: number; exitedAt?: string } | null;
+  outcome: 'success' | 'error';
+  error: string | null;
+  elapsedMs: number;
+}
+
+/**
+ * Append a JSON lines entry to the automation log.
+ * Rotates by dropping the oldest half when the file exceeds 1MB.
+ */
+async function writeAutomationLog(entry: AutomationLogEntry): Promise<void> {
+  try {
+    const dir = path.dirname(AUTOMATION_LOG_PATH);
+    await fs.mkdir(dir, { recursive: true });
+
+    const line = JSON.stringify(entry) + '\n';
+    await fs.appendFile(AUTOMATION_LOG_PATH, line);
+
+    // Check size and rotate if needed
+    try {
+      const stat = await fs.stat(AUTOMATION_LOG_PATH);
+      if (stat.size > AUTOMATION_LOG_MAX_BYTES) {
+        const content = await fs.readFile(AUTOMATION_LOG_PATH, 'utf-8');
+        const lines = content.trim().split('\n');
+        // Keep the newest half
+        const keep = lines.slice(Math.floor(lines.length / 2));
+        await fs.writeFile(AUTOMATION_LOG_PATH, keep.join('\n') + '\n');
+      }
+    } catch { /* rotation is best-effort */ }
+  } catch (err) {
+    console.error('[scheduler] Failed to write automation log:', err);
+  }
+}
+
+interface LivenessResult {
+  status: 'running' | 'stopped' | 'unknown';
+  exitCode?: number;
+  exitedAt?: string;
+}
+
 /**
  * Check if a session is alive after startup (used for fresh sessions).
  *
@@ -84,17 +133,17 @@ async function fetchWithTimeout(url: string, opts?: RequestInit): Promise<Respon
  * don't need to verify prompt delivery. We just need to confirm the session
  * didn't crash during startup (e.g. auth failure, invalid config).
  */
-async function checkSessionAlive(sessionName: string): Promise<'running' | 'stopped' | 'unknown'> {
+async function checkSessionAlive(sessionName: string): Promise<LivenessResult> {
   await new Promise(r => setTimeout(r, LIVENESS_CHECK_MS));
   try {
     const res = await fetchWithTimeout(`${BRIDGE_URL}/sessions/${encodeURIComponent(sessionName)}`);
-    if (!res.ok) return 'unknown';
+    if (!res.ok) return { status: 'unknown' };
     const data = await res.json();
-    if (data.status === 'stopped') return 'stopped';
-    if (data.status === 'running' || data.status === 'detached') return 'running';
-    return 'unknown';
+    if (data.status === 'stopped') return { status: 'stopped', exitCode: data.exitCode, exitedAt: data.exitedAt };
+    if (data.status === 'running' || data.status === 'detached') return { status: 'running' };
+    return { status: 'unknown' };
   } catch {
-    return 'unknown';
+    return { status: 'unknown' };
   }
 }
 
@@ -357,6 +406,30 @@ export async function triggerAutomation(
   }
 
   const isFresh = config.freshSession || false;
+  const startTime = Date.now();
+
+  // Tracking for automation log
+  let bridgeRequestInfo: AutomationLogEntry['bridgeRequest'] = null;
+  let livenessInfo: AutomationLogEntry['livenessCheck'] = null;
+
+  const logAndReturn = async (result: KickoffResult): Promise<KickoffResult> => {
+    await writeAutomationLog({
+      timestamp: new Date().toISOString(),
+      cardId: card.id,
+      cardTitle: card.title,
+      projectId,
+      trigger: options.trigger,
+      provider,
+      sessionName,
+      fresh: isFresh,
+      bridgeRequest: bridgeRequestInfo,
+      livenessCheck: livenessInfo,
+      outcome: result.success ? 'success' : 'error',
+      error: result.error || null,
+      elapsedMs: Date.now() - startTime,
+    });
+    return result;
+  };
 
   try {
     console.log(`[scheduler] Creating session: ${sessionName} (fresh: ${isFresh}, provider: ${provider})`);
@@ -379,6 +452,7 @@ export async function triggerAutomation(
 
     if (!createRes.ok && createRes.status === 409 && !isFresh) {
       // Session exists and not fresh — try sending input directly (resume fallback)
+      bridgeRequestInfo = { status: 409 };
       console.log(`[scheduler] Session ${sessionName} returned 409, sending prompt via input endpoint`);
       const inputRes = await fetchWithTimeout(`${BRIDGE_URL}/sessions/${encodeURIComponent(sessionName)}/input`, {
         method: 'POST',
@@ -386,12 +460,22 @@ export async function triggerAutomation(
         body: JSON.stringify({ data: fullPrompt + '\r' }),
       });
       if (!inputRes.ok) {
-        return { cardId: card.id, projectId, success: false, error: `Input failed: ${await inputRes.text()}` };
+        const body = await inputRes.text();
+        return logAndReturn({ cardId: card.id, projectId, success: false, error: `Input failed (${inputRes.status}): ${body}` });
       }
     } else if (!createRes.ok) {
-      return { cardId: card.id, projectId, success: false, error: `Session create failed: ${await createRes.text()}` };
+      let errorDetail: string;
+      try {
+        const body = await createRes.json();
+        errorDetail = body.error || JSON.stringify(body);
+      } catch {
+        errorDetail = await createRes.text();
+      }
+      bridgeRequestInfo = { status: createRes.status, error: errorDetail };
+      return logAndReturn({ cardId: card.id, projectId, success: false, error: `Session create failed (${createRes.status}): ${errorDetail}` });
     } else {
       const createData = await createRes.json();
+      bridgeRequestInfo = { status: createRes.status, resumed: createData.resumed, pid: createData.pid };
       console.log(`[scheduler] Session created: ${sessionName} (status: ${createData.status}, resumed: ${createData.resumed}, pid: ${createData.pid})`);
     }
 
@@ -399,12 +483,20 @@ export async function triggerAutomation(
     // Prompt was delivered via CLI args. Just verify the session didn't crash.
     // No retry needed — OS guarantees prompt delivery.
     if (isFresh) {
-      const status = await checkSessionAlive(sessionName);
-      if (status === 'stopped') {
-        return { cardId: card.id, projectId, success: false, sessionName, error: 'Session stopped during startup (possible auth/config error)' };
+      const liveness = await checkSessionAlive(sessionName);
+      livenessInfo = { type: 'checkSessionAlive', result: liveness.status, delayMs: LIVENESS_CHECK_MS, exitCode: liveness.exitCode, exitedAt: liveness.exitedAt };
+      if (liveness.status === 'stopped') {
+        // Exit code 0 means the session completed normally — not a failure.
+        // Fast automations can finish within the liveness check window.
+        if (liveness.exitCode === 0) {
+          return logAndReturn({ cardId: card.id, projectId, success: true, sessionName });
+        }
+        const exitDetail = liveness.exitCode !== undefined ? ` (exit code ${liveness.exitCode})` : '';
+        const aliveDetail = liveness.exitedAt ? `, alive ${((new Date(liveness.exitedAt).getTime() - startTime) / 1000).toFixed(1)}s` : '';
+        return logAndReturn({ cardId: card.id, projectId, success: false, sessionName, error: `Session stopped during startup${exitDetail}${aliveDetail}` });
       }
       // 'running' or 'unknown' — session is alive (or bridge is slow). Either way, prompt was delivered.
-      return { cardId: card.id, projectId, success: true, sessionName };
+      return logAndReturn({ cardId: card.id, projectId, success: true, sessionName });
     }
 
     // --- Resume session path ---
@@ -412,7 +504,8 @@ export async function triggerAutomation(
     // so we check for activity and retry if needed.
     const active = await waitForActivity(sessionName);
     if (active) {
-      return { cardId: card.id, projectId, success: true, sessionName };
+      livenessInfo = { type: 'waitForActivity', result: 'active' };
+      return logAndReturn({ cardId: card.id, projectId, success: true, sessionName });
     }
 
     // No activity detected — retry by re-sending prompt via bracketed paste
@@ -436,13 +529,15 @@ export async function triggerAutomation(
 
       const retryActive = await waitForActivity(sessionName);
       if (retryActive) {
-        return { cardId: card.id, projectId, success: true, sessionName };
+        livenessInfo = { type: 'waitForActivity', result: 'active (retry)' };
+        return logAndReturn({ cardId: card.id, projectId, success: true, sessionName });
       }
     }
 
-    return { cardId: card.id, projectId, success: false, sessionName, error: 'No activity detected after retry' };
+    livenessInfo = { type: 'waitForActivity', result: 'inactive after retry' };
+    return logAndReturn({ cardId: card.id, projectId, success: false, sessionName, error: 'No activity detected after retry' });
   } catch (err) {
-    return { cardId: card.id, projectId, success: false, sessionName, error: (err as Error).message };
+    return logAndReturn({ cardId: card.id, projectId, success: false, sessionName, error: (err as Error).message });
   }
 }
 
@@ -478,12 +573,17 @@ export async function updateCardAutomation(
 }
 
 /**
- * Send error notification via messaging
+ * Send error notification via messaging with actionable detail.
  */
-async function sendErrorNotification(cardTitle: string, error: string): Promise<void> {
+async function sendErrorNotification(cardTitle: string, error: string, sessionName?: string): Promise<void> {
   try {
     const { execSync } = await import('child_process');
-    execSync(`sly-messaging send "Automation kickoff failed: ${cardTitle.replace(/"/g, '\\"')} — ${error.replace(/"/g, '\\"')}"`, {
+    const lines = [`Automation failed: ${cardTitle}`];
+    if (sessionName) lines.push(`Session: ${sessionName}`);
+    lines.push(`Error: ${error}`);
+    lines.push(`Log: ~/.slycode/logs/automation.log`);
+    const msg = lines.join('\n').replace(/"/g, '\\"');
+    execSync(`sly-messaging send "${msg}"`, {
       timeout: 10_000,
       stdio: 'pipe',
     });
@@ -560,7 +660,7 @@ async function checkAutomations(): Promise<void> {
                     result.error.includes('No automation config')
                   );
                   if (isHardFailure) {
-                    await sendErrorNotification(card.title, result.error || 'Unknown error');
+                    await sendErrorNotification(card.title, result.error || 'Unknown error', result.sessionName);
                   } else {
                     console.log(`[scheduler] Soft failure for ${card.id}, skipping notification: ${result.error}`);
                   }