create-walle 0.9.13 → 0.9.15

package/template/claude-task-manager/public/js/session-status-precedence.js

@@ -0,0 +1,125 @@
+'use strict';
+
+(function initSessionStatusPrecedence(root, factory) {
+  if (typeof module === 'object' && module.exports) {
+    module.exports = factory();
+  } else {
+    root.SessionStatusPrecedence = factory();
+  }
+})(typeof globalThis !== 'undefined' ? globalThis : this, function buildSessionStatusPrecedence() {
+  const AUTHORITATIVE_STATUS_TTL_MS = 120000;
+  const SERVER_LIVE_STATUS_TTL_MS = 10000;
+  const STREAM_STATUS_TTL_MS = 60000;
+  const SERVER_WORKING_TTL_MS = 10000;
+  const RECENT_OUTPUT_TTL_MS = 5000;
+  const RECENT_INPUT_TTL_MS = 3000;
+
+  const STATUS_TEXT = {
+    running: 'Running',
+    waiting: 'Waiting',
+    idle: 'Idle',
+    exited: 'Exited',
+  };
+
+  function normalizeLiveSessionStatus(status) {
+    const text = String(status || '').toLowerCase();
+    if (!text) return '';
+    if (text === 'busy' || text === 'active' || text === 'thinking') return 'running';
+    if (text === 'waiting_input' || text === 'waiting-for-input') return 'waiting';
+    if (Object.prototype.hasOwnProperty.call(STATUS_TEXT, text)) return text;
+    return '';
+  }
+
+  function result(status, source) {
+    const normalized = normalizeLiveSessionStatus(status);
+    if (!normalized) return null;
+    return {
+      cls: normalized,
+      text: STATUS_TEXT[normalized] || 'Idle',
+      source: source || normalized,
+    };
+  }
+
+  function parseTimeMs(value, fallback = 0, parser) {
+    if (value == null || value === '') return fallback || 0;
+    if (typeof parser === 'function') {
+      const parsed = parser(value);
+      if (parsed) return parsed;
+    }
+    if (typeof value === 'number' && Number.isFinite(value)) return value;
+    const parsed = Date.parse(String(value));
+    return Number.isFinite(parsed) ? parsed : (fallback || 0);
+  }
+
+  function isFresh(timestamp, now, ttl) {
+    return Boolean(timestamp && (now - timestamp) < ttl);
+  }
+
+  function resolveSessionStatus(input = {}, options = {}) {
+    const now = options.now || Date.now();
+    const parser = options.parseTimeMs;
+    if (input.metaType === 'walle') {
+      return input.walleGenerating
+        ? result('running', 'walle-generating')
+        : result('idle', 'walle-idle');
+    }
+
+    const serverLiveStatusAt = parseTimeMs(input.serverLiveStatusAt, 0, parser);
+    const serverLive = result(input.serverLiveStatus, 'server-live');
+    if (serverLive && isFresh(serverLiveStatusAt, now, SERVER_LIVE_STATUS_TTL_MS)) {
+      return serverLive;
+    }
+
+    const serverWorkingAt = parseTimeMs(input.serverWorkingAt, 0, parser);
+    const serverWorkingEventAt = parseTimeMs(input.serverWorkingEventAt, serverWorkingAt, parser);
+    const waitingAt = parseTimeMs(input.waitingForInputAt, 0, parser);
+    const waitingForInput = Boolean(input.waitingForInput);
+    const serverWorking = Boolean(serverWorkingAt &&
+      (now - serverWorkingAt) < SERVER_WORKING_TTL_MS &&
+      (!waitingForInput || !waitingAt || serverWorkingEventAt >= waitingAt));
+
+    const streamStatusAt = parseTimeMs(input.streamStatusAt, 0, parser);
+    const streamStatus = normalizeLiveSessionStatus(input.streamStatus);
+    const streamFresh = Boolean(streamStatus && isFresh(streamStatusAt, now, STREAM_STATUS_TTL_MS));
+    const streamRunning = streamFresh && streamStatus === 'running';
+    const lastOutputAt = Math.max(
+      parseTimeMs(input.lastOutputAt, 0, parser),
+      parseTimeMs(input.metaLastPtyActivity, 0, parser)
+    );
+    const recentOutput = Boolean(lastOutputAt && (now - lastOutputAt) < RECENT_OUTPUT_TTL_MS);
+    const codexRunningHold = Boolean(input.codexRunningHold);
+
+    if (input.authoritativeSource) {
+      const authAt = parseTimeMs(input.authoritativeStatusAt, 0, parser);
+      if (isFresh(authAt, now, AUTHORITATIVE_STATUS_TTL_MS)) {
+        if (input.working) return result('running', 'authoritative-working');
+        if (waitingForInput) return result('waiting', 'authoritative-waiting');
+        const newerRunningEvidence =
+          serverWorking ||
+          (streamRunning && (!authAt || streamStatusAt >= authAt)) ||
+          (recentOutput && (!authAt || lastOutputAt >= authAt));
+        if (newerRunningEvidence) return result('running', 'newer-running-evidence');
+        return result('idle', 'authoritative-idle');
+      }
+    }
+
+    if (serverWorking) return result('running', 'server-working');
+    if (waitingForInput) return result('waiting', 'waiting-for-input');
+    if (codexRunningHold) return result('running', 'codex-running-hold');
+    if (streamFresh) return result(streamStatus, 'stream-status');
+    if (waitingForInput && !recentOutput) return result('waiting', 'waiting-fallback');
+    if (recentOutput) return result('running', 'recent-output');
+    const lastInputAt = parseTimeMs(input.lastInputAt, 0, parser);
+    if (lastInputAt && (now - lastInputAt) < RECENT_INPUT_TTL_MS) return result('running', 'recent-input');
+    return result('idle', 'default-idle');
+  }
+
+  return {
+    AUTHORITATIVE_STATUS_TTL_MS,
+    SERVER_LIVE_STATUS_TTL_MS,
+    normalizeLiveSessionStatus,
+    liveStatusResult: (status) => result(status, 'live-status'),
+    parseTimeMs,
+    resolveSessionStatus,
+  };
+});

package/template/claude-task-manager/public/js/setup.js

@@ -443,8 +443,12 @@ async function loadStatus() {
     }
     // Slack status now handled by loadConnectedServices()
     if (d.version) {
-      var vl = document.getElementById('setup-version-label');
-      if (vl) vl.textContent = 'Wall-E v' + d.version;
+      if (typeof window.setAppVersion === 'function') {
+        window.setAppVersion(d.version, { product: 'create-walle' });
+      } else {
+        var vl = document.getElementById('setup-version-label');
+        if (vl) vl.textContent = 'CTM / Wall-E v' + d.version;
+      }
     }
     if (d.ctm_data_dir) document.getElementById('setup-ctm-data-dir').value = d.ctm_data_dir;
     if (d.walle_data_dir) document.getElementById('setup-walle-data-dir').value = d.walle_data_dir;
@@ -1069,11 +1073,19 @@ async function saveDataDirs() {
 }
 
 // ── MCP Integrations ────────────────────────────────────────────────
-var MCP_ICONS = { 'Claude Code': '\uD83E\uDD16', 'Cursor': '\u2328\uFE0F', 'Windsurf': '\uD83C\uDF0A', 'Claude Desktop': '\uD83D\uDDA5\uFE0F' };
+var MCP_ICONS = {
+  'Claude Code': '\uD83E\uDD16',
+  'Claude Code Global': '\uD83E\uDD16',
+  'Codex': '\u25CE',
+  'Cursor': '\u2328\uFE0F',
+  'Windsurf': '\uD83C\uDF0A',
+  'Claude Desktop': '\uD83D\uDDA5\uFE0F',
+};
 var MCP_STATUS_MAP = {
   configured:     { label: 'Connected', cls: 'badge-connected' },
   not_configured: { label: 'Not configured', cls: 'badge-missing' },
   wrong_port:     { label: 'Wrong port', cls: 'badge-warn' },
+  invalid_config: { label: 'Invalid config', cls: 'badge-warn' },
   not_installed:  { label: 'Not installed', cls: 'badge-dim' },
 };
 
@@ -1084,6 +1096,14 @@ function mcpDimMsg(text) {
   return d;
 }
 
+function mcpActionText(item) {
+  if (item.status === 'configured') return 'Ready for new agent sessions. Restart the AI tool if it was already open.';
+  if (item.status === 'not_configured') return 'Repair Configs will add the wall-e MCP server entry.';
+  if (item.status === 'wrong_port') return 'Repair Configs will update the wall-e entry to the current Wall-E port.';
+  if (item.status === 'invalid_config') return 'Fix the JSON syntax in this file, then run Repair Configs again.';
+  return '';
+}
+
 function buildMcpRow(item) {
   var info = MCP_STATUS_MAP[item.status] || { label: item.status, cls: 'badge-dim' };
   var row = document.createElement('div');
@@ -1108,6 +1128,13 @@ function buildMcpRow(item) {
     descDiv.textContent = item.configPath;
     textWrap.appendChild(descDiv);
   }
+  var actionText = mcpActionText(item);
+  if (actionText) {
+    var actionDiv = document.createElement('div');
+    actionDiv.className = 'integration-desc integration-action';
+    actionDiv.textContent = actionText;
+    textWrap.appendChild(actionDiv);
+  }
 
   infoDiv.appendChild(iconDiv);
   infoDiv.appendChild(textWrap);
@@ -1123,25 +1150,38 @@ function buildMcpRow(item) {
 
 async function loadMcpIntegrations() {
   var container = document.getElementById('setup-mcp-integrations');
+  var testBtn = document.getElementById('setup-mcp-test-btn');
+  var fixBtn = document.getElementById('setup-mcp-fix-btn');
   try {
     var r = await fetch('/api/wall-e/mcp/integrations');
     var d = await r.json();
-    if (d.wallePort) { _mcpPort = d.wallePort; var portEl = document.getElementById('setup-mcp-port-display'); if (portEl) portEl.textContent = d.wallePort; }
-    if (!d.data || !d.data.length) { container.replaceChildren(mcpDimMsg('No AI tools detected.')); return; }
+    if (d.wallePort) {
+      _mcpPort = d.wallePort;
+      ['setup-mcp-port-display', 'setup-mcp-port-display-toml'].forEach(function(id) {
+        var portEl = document.getElementById(id);
+        if (portEl) portEl.textContent = d.wallePort;
+      });
+    }
+    if (!d.data || !d.data.length) {
+      container.replaceChildren(mcpDimMsg('No AI tools detected.'));
+      if (testBtn) testBtn.disabled = false;
+      if (fixBtn) fixBtn.style.display = 'none';
+      return;
+    }
 
-    var hasConfigured = false, needsFix = false;
+    var needsFix = false;
     var frag = document.createDocumentFragment();
     for (var i = 0; i < d.data.length; i++) {
       var item = d.data[i];
-      if (item.status === 'configured') hasConfigured = true;
-      if (item.status === 'not_configured' || item.status === 'wrong_port') needsFix = true;
+      if (item.status === 'not_configured' || item.status === 'wrong_port' || item.status === 'invalid_config') needsFix = true;
       frag.appendChild(buildMcpRow(item));
     }
     container.replaceChildren(frag);
-    document.getElementById('setup-mcp-test-btn').disabled = !hasConfigured;
-    if (needsFix) document.getElementById('setup-mcp-fix-btn').style.display = '';
+    if (testBtn) testBtn.disabled = false;
+    if (fixBtn) fixBtn.style.display = needsFix ? '' : 'none';
   } catch {
     container.replaceChildren(mcpDimMsg('Could not load integrations.'));
+    if (testBtn) testBtn.disabled = false;
   }
 }
 
@@ -1151,17 +1191,15 @@ async function testMcpConnection() {
   btn.disabled = true; btn.textContent = 'Testing\u2026';
   resultEl.style.display = 'none';
   try {
-    var r = await fetch('http://localhost:' + _mcpPort + '/mcp', {
-      method: 'POST', headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'initialize', params: { protocolVersion: '2025-03-26', capabilities: {}, clientInfo: { name: 'setup-wizard', version: '1.0' } } }),
-    });
+    var r = await fetch('/api/wall-e/mcp/test');
     var d = await r.json();
-    if (d.result && d.result.serverInfo) {
+    var data = d.data || {};
+    if (data.ok) {
       resultEl.className = 'test-result ok'; resultEl.style.display = 'block';
-      resultEl.textContent = '\u2713 MCP server responding \u2014 ' + d.result.serverInfo.name + ' v' + (d.result.serverInfo.version || '?');
+      resultEl.textContent = '\u2713 Wall-E MCP endpoint is reachable with ' + (data.toolCount || 0) + ' tools.';
     } else {
       resultEl.className = 'test-result fail'; resultEl.style.display = 'block';
-      resultEl.textContent = '\u2715 Unexpected response';
+      resultEl.textContent = '\u2715 Wall-E MCP endpoint is not reachable on port ' + _mcpPort + ': ' + (data.error || 'unexpected response');
     }
   } catch (e) {
     resultEl.className = 'test-result fail'; resultEl.style.display = 'block';
@@ -1177,13 +1215,18 @@ async function fixMcpConfigs() {
     var r = await fetch('/api/wall-e/mcp/inject', { method: 'POST' });
     var d = await r.json();
     if (d.ok) {
-      setupToast('MCP configs updated');
+      var errors = (d.results || []).filter(function(x) { return x.action === 'error'; });
+      if (errors.length) {
+        setupToast('Some MCP configs need manual repair: ' + errors.map(function(x) { return x.tool; }).join(', '), 'error');
+      } else {
+        setupToast('MCP configs updated');
+      }
       loadMcpIntegrations();
     } else {
       setupToast(d.error || 'Fix failed', 'error');
     }
   } catch (e) { setupToast(e.message, 'error'); }
-  btn.disabled = false; btn.textContent = 'Fix All';
+  btn.disabled = false; btn.textContent = 'Repair Configs';
 }
 
 // ── Embeddings ──────────────────────────────────────────────────────