instar 0.23.14 → 0.23.16

package/dashboard/index.html

@@ -1206,6 +1206,213 @@
       to { opacity: 1; transform: translateY(0); }
     }
 
+    /* ── New Session modal ────────────────────────────── */
+    .modal-backdrop {
+      position: fixed;
+      inset: 0;
+      background: rgba(0,0,0,0.6);
+      z-index: 5000;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+    }
+
+    .modal-dialog {
+      background: var(--bg-panel);
+      border: 1px solid var(--border);
+      border-radius: 12px;
+      padding: 24px;
+      width: 380px;
+      max-width: 90vw;
+      box-shadow: 0 8px 32px rgba(0,0,0,0.6);
+    }
+
+    .modal-dialog h3 {
+      color: var(--text-bright);
+      font-size: 16px;
+      margin-bottom: 16px;
+    }
+
+    .modal-field {
+      margin-bottom: 14px;
+    }
+
+    .modal-field label {
+      display: block;
+      font-size: 12px;
+      color: var(--text-dim);
+      margin-bottom: 4px;
+      text-transform: uppercase;
+      letter-spacing: 0.04em;
+    }
+
+    .modal-field input[type="text"] {
+      width: 100%;
+      padding: 10px 12px;
+      border-radius: 6px;
+      border: 1px solid var(--border);
+      background: var(--bg);
+      color: var(--text-bright);
+      font-size: 14px;
+      outline: none;
+      box-sizing: border-box;
+    }
+
+    .modal-field input[type="text"]:focus {
+      border-color: var(--accent-dim);
+    }
+
+    .modal-toggle {
+      display: flex;
+      align-items: center;
+      gap: 10px;
+      cursor: pointer;
+      user-select: none;
+    }
+
+    .modal-toggle input[type="checkbox"] {
+      appearance: none;
+      width: 36px;
+      height: 20px;
+      border-radius: 10px;
+      background: #333;
+      position: relative;
+      cursor: pointer;
+      transition: background 0.2s;
+      flex-shrink: 0;
+    }
+
+    .modal-toggle input[type="checkbox"]::after {
+      content: '';
+      position: absolute;
+      top: 2px;
+      left: 2px;
+      width: 16px;
+      height: 16px;
+      border-radius: 50%;
+      background: #888;
+      transition: transform 0.2s, background 0.2s;
+    }
+
+    .modal-toggle input[type="checkbox"]:checked {
+      background: var(--accent-dim);
+    }
+
+    .modal-toggle input[type="checkbox"]:checked::after {
+      transform: translateX(16px);
+      background: #fff;
+    }
+
+    .modal-toggle span {
+      font-size: 13px;
+      color: var(--text);
+    }
+
+    .modal-hint {
+      font-size: 11px;
+      color: var(--text-dim);
+      margin-top: 4px;
+      font-style: italic;
+    }
+
+    .modal-actions {
+      display: flex;
+      gap: 8px;
+      margin-top: 20px;
+      justify-content: flex-end;
+    }
+
+    .modal-actions button {
+      padding: 8px 18px;
+      border-radius: 6px;
+      font-size: 13px;
+      font-weight: 500;
+      cursor: pointer;
+      border: 1px solid var(--border);
+    }
+
+    .modal-btn-cancel {
+      background: var(--bg);
+      color: var(--text);
+    }
+
+    .modal-btn-cancel:hover {
+      background: var(--bg-hover);
+    }
+
+    .modal-btn-create {
+      background: var(--accent-dim);
+      color: #000;
+      border-color: var(--accent-dim);
+    }
+
+    .modal-btn-create:hover {
+      background: var(--accent);
+    }
+
+    .modal-btn-create:disabled {
+      opacity: 0.4;
+      cursor: not-allowed;
+    }
+
+    /* ── New session button ───────────────────────────── */
+    .new-session-btn {
+      width: 28px;
+      height: 28px;
+      border-radius: 6px;
+      border: 1px solid var(--border);
+      background: var(--bg);
+      color: var(--accent);
+      font-size: 18px;
+      cursor: pointer;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      transition: all 0.15s;
+      line-height: 1;
+    }
+
+    .new-session-btn:hover {
+      background: var(--bg-hover);
+      border-color: var(--accent-dim);
+    }
+
+    /* ── Session close button ─────────────────────────── */
+    .session-close-btn {
+      background: none;
+      border: none;
+      color: var(--text-dim);
+      cursor: pointer;
+      font-size: 14px;
+      padding: 2px 6px;
+      border-radius: 4px;
+      opacity: 0;
+      transition: opacity 0.15s, color 0.15s;
+      flex-shrink: 0;
+      line-height: 1;
+    }
+
+    .session-item:hover .session-close-btn,
+    .session-item.active .session-close-btn {
+      opacity: 1;
+    }
+
+    .session-close-btn:hover {
+      color: var(--red);
+      background: rgba(239, 68, 68, 0.1);
+    }
+
+    .session-name-row {
+      display: flex;
+      align-items: center;
+      gap: 4px;
+    }
+
+    .session-name-row .session-name {
+      flex: 1;
+      min-width: 0;
+    }
+
     /* Conflict dialog */
     .conflict-overlay {
       position: fixed;
@@ -1493,7 +1700,10 @@
     <aside class="sidebar" id="sessionsTab">
       <div class="sidebar-header">
         <h2>Sessions</h2>
-        <span class="session-count" id="sessionCount">0</span>
+        <div style="display:flex;align-items:center;gap:8px;">
+          <span class="session-count" id="sessionCount">0</span>
+          <button class="new-session-btn" onclick="openNewSessionModal()" title="New session">+</button>
+        </div>
       </div>
       <div class="session-list" id="sessionList">
         <div class="empty-state" id="emptyState">
@@ -1528,6 +1738,8 @@
             <button class="action-btn action-arrow" onclick="sendKey('Down')" title="Arrow Down">&darr;</button>
             <button class="action-btn action-arrow" onclick="sendKey('Left')" title="Arrow Left">&larr;</button>
             <button class="action-btn action-arrow" onclick="sendKey('Right')" title="Arrow Right">&rarr;</button>
+            <span class="action-separator"></span>
+            <button class="action-btn danger" onclick="closeActiveSession()" title="Close session">&times; Close</button>
           </div>
         </div>
         <div class="terminal-container" id="terminalContainer"></div>
@@ -1581,6 +1793,29 @@
     </div>
   </div>
 
+  <!-- New Session modal -->
+  <div class="modal-backdrop" id="newSessionModal" style="display:none" onclick="closeNewSessionModal(event)">
+    <div class="modal-dialog" onclick="event.stopPropagation()">
+      <h3>New Session</h3>
+      <div class="modal-field">
+        <label for="newSessionName">Topic Name</label>
+        <input type="text" id="newSessionName" placeholder="e.g. dashboard-redesign" maxlength="128"
+               onkeydown="if(event.key==='Enter')createNewSession()" autofocus>
+      </div>
+      <div class="modal-field">
+        <label class="modal-toggle">
+          <input type="checkbox" id="newSessionHeadless">
+          <span>Headless (no Telegram topic)</span>
+        </label>
+        <div class="modal-hint">Headless sessions still appear in the dashboard but won't create a Telegram topic.</div>
+      </div>
+      <div class="modal-actions">
+        <button class="modal-btn-cancel" onclick="closeNewSessionModal()">Cancel</button>
+        <button class="modal-btn-create" id="createSessionBtn" onclick="createNewSession()">Create Session</button>
+      </div>
+    </div>
+  </div>
+
   <!-- Drop Zone tab -->
   <div class="dropzone-container" id="dropzoneTab" style="display:none">
     <div class="dropzone-panel">
@@ -1646,6 +1881,9 @@
     let activeSession = null;
     let term = null;
     let fitAddon = null;
+    let historyLinesLoaded = 2000; // matches initial subscribe capture
+    let historyLoading = false;
+    let historyExhausted = false; // true when we've loaded all available history
 
     // ── Auth ─────────────────────────────────────────────────
     function authenticate() {
@@ -1769,6 +2007,26 @@
           }
           break;
 
+        case 'history':
+          if (msg.session === activeSession && term) {
+            const prevLineCount = historyLinesLoaded;
+            historyLinesLoaded = msg.lines;
+            // Check if we got more content than before
+            const newLineCount = (msg.data || '').split('\n').length;
+            const oldLineCount = prevLineCount;
+            if (newLineCount <= oldLineCount + 10) {
+              // No meaningful new content — we've hit the buffer limit
+              historyExhausted = true;
+            }
+            // Rewrite terminal with expanded history
+            term.clear();
+            term.write(msg.data);
+            // Don't auto-scroll — user is reading history
+            historyLoading = false;
+            hideHistorySpinner();
+          }
+          break;
+
         case 'session_ended':
           if (msg.session === activeSession) {
             // Session ended — show in terminal
@@ -1892,7 +2150,10 @@
         }
 
         el.innerHTML = `
-          <div class="session-name">${escapeHtml(session.name)}</div>
+          <div class="session-name-row">
+            <div class="session-name">${escapeHtml(session.name)}</div>
+            <button class="session-close-btn" data-tmux="${escapeHtml(session.tmuxSession)}" data-name="${escapeHtml(session.name)}" onclick="event.stopPropagation();closeSession(this.dataset.tmux,this.dataset.name)" title="Close session">&times;</button>
+          </div>
           <div class="session-meta">
             <span class="type-badge ${sType}">${sType}</span>
             <span class="model-badge ${model}">${model}</span>
@@ -2050,6 +2311,96 @@
       wsSend({ type: 'key', session: activeSession, key: text });
     }
 
+    // ── New Session Modal ────────────────────────────────────
+    function openNewSessionModal() {
+      document.getElementById('newSessionModal').style.display = 'flex';
+      const nameInput = document.getElementById('newSessionName');
+      nameInput.value = '';
+      document.getElementById('newSessionHeadless').checked = false;
+      setTimeout(() => nameInput.focus(), 50);
+    }
+
+    function closeNewSessionModal(e) {
+      if (e && e.target !== e.currentTarget) return;
+      document.getElementById('newSessionModal').style.display = 'none';
+    }
+
+    async function createNewSession() {
+      const nameInput = document.getElementById('newSessionName');
+      const headless = document.getElementById('newSessionHeadless').checked;
+      const name = nameInput.value.trim();
+      const btn = document.getElementById('createSessionBtn');
+
+      if (!name) {
+        nameInput.focus();
+        nameInput.style.borderColor = 'var(--red)';
+        setTimeout(() => nameInput.style.borderColor = '', 2000);
+        return;
+      }
+
+      btn.disabled = true;
+      btn.textContent = 'Creating...';
+
+      try {
+        const resp = await fetch('/sessions/create', {
+          method: 'POST',
+          headers: {
+            'Authorization': `Bearer ${token}`,
+            'Content-Type': 'application/json',
+          },
+          body: JSON.stringify({ name, headless }),
+        });
+        const data = await resp.json();
+
+        if (!resp.ok) {
+          showToast(data.error || 'Failed to create session', 'error');
+          return;
+        }
+
+        showToast(`Session "${name}" created${data.topicId ? ' with Telegram topic' : ' (headless)'}`, 'success');
+        document.getElementById('newSessionModal').style.display = 'none';
+      } catch (err) {
+        showToast('Network error: ' + (err.message || 'Cannot reach server'), 'error');
+      } finally {
+        btn.disabled = false;
+        btn.textContent = 'Create Session';
+      }
+    }
+
+    // ── Close Session ─────────────────────────────────────────
+    async function closeSession(tmuxSession, sessionName) {
+      if (!confirm(`Close session "${sessionName}"?`)) return;
+
+      try {
+        const resp = await fetch(`/sessions/${encodeURIComponent(tmuxSession)}`, {
+          method: 'DELETE',
+          headers: { 'Authorization': `Bearer ${token}` },
+        });
+        const data = await resp.json();
+
+        if (!resp.ok) {
+          showToast(data.error || 'Failed to close session', 'error');
+          return;
+        }
+
+        showToast(`Session "${sessionName}" closed`, 'success');
+
+        // If this was the active session, clear terminal
+        if (activeSession === tmuxSession) {
+          goBack();
+        }
+      } catch (err) {
+        showToast('Network error: ' + (err.message || 'Cannot reach server'), 'error');
+      }
+    }
+
+    function closeActiveSession() {
+      if (!activeSession) return;
+      const session = sessions.find(s => s.tmuxSession === activeSession);
+      const name = session ? session.name : activeSession;
+      closeSession(activeSession, name);
+    }
+
     // ── Helpers ───────────────────────────────────────────────
     function formatElapsed(isoStr) {
       const ms = Date.now() - new Date(isoStr).getTime();

package/dist/commands/server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/commands/server.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAwPH,UAAU,YAAY;IACpB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb;2DACuD;IACvD,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAoiCD,wBAAsB,WAAW,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAk3EtE;AAED,wBAAsB,UAAU,CAAC,OAAO,EAAE;IAAE,GAAG,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAsDzE;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,aAAa,CAAC,OAAO,EAAE;IAAE,GAAG,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAuD5E"}
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/commands/server.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAwPH,UAAU,YAAY;IACpB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb;2DACuD;IACvD,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAgkCD,wBAAsB,WAAW,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAy5EtE;AAED,wBAAsB,UAAU,CAAC,OAAO,EAAE;IAAE,GAAG,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAsDzE;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,aAAa,CAAC,OAAO,EAAE;IAAE,GAAG,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAuD5E"}

package/dist/commands/server.js

@@ -283,7 +283,7 @@ async function spawnSessionForTopic(sessionManager, telegram, sessionName, topic
     let usedFallback = false;
     if (topicMemory?.isReady()) {
         try {
-            contextContent = topicMemory.formatContextForSession(topicId, 30);
+            contextContent = topicMemory.formatContextForSession(topicId, 50);
         }
         catch (err) {
             // @silent-fallback-ok — TopicMemory format, JSONL fallback
@@ -294,12 +294,16 @@ async function spawnSessionForTopic(sessionManager, telegram, sessionName, topic
     if (!contextContent) {
         usedFallback = true;
         try {
-            const history = telegram.getTopicHistory(topicId, 20);
+            const history = telegram.getTopicHistory(topicId, 50);
             if (history.length > 0) {
                 const lines = [];
                 lines.push(`--- Thread History (last ${history.length} messages) ---`);
                 lines.push(`IMPORTANT: Read this history carefully before taking any action.`);
                 lines.push(`Your task is to continue THIS conversation, not start something new.`);
+                const topicName = telegram.getTopicName?.(topicId);
+                if (topicName) {
+                    lines.push(`Topic: ${topicName}`);
+                }
                 lines.push(``);
                 for (const m of history) {
                     // Use actual sender name if available (multi-user topics), fall back to generic
@@ -307,7 +311,7 @@ async function spawnSessionForTopic(sessionManager, telegram, sessionName, topic
                         ? (m.senderName || 'User')
                         : 'Agent';
                     const ts = m.timestamp ? new Date(m.timestamp).toISOString().slice(11, 19) : '??:??';
-                    const text = (m.text || '').slice(0, 300);
+                    const text = (m.text || '').slice(0, 2000);
                     lines.push(`[${ts}] ${sender}: ${text}`);
                 }
                 lines.push(``);
@@ -434,13 +438,30 @@ async function spawnSessionForTopic(sessionManager, telegram, sessionName, topic
     if (resumeSessionId) {
         _topicResumeMap?.remove(topicId);
     }
+    // Proactive UUID save — schedule an immediate discovery attempt after spawn.
+    // The JSONL file appears ~3-5 seconds after Claude Code starts.
+    // This is belt-and-suspenders alongside the 60s heartbeat and beforeSessionKill.
+    if (_topicResumeMap && !resumeSessionId) {
+        setTimeout(() => {
+            try {
+                const uuid = _topicResumeMap.findClaudeSessionUuid();
+                if (uuid) {
+                    _topicResumeMap.save(topicId, uuid, newSessionName);
+                    console.log(`[spawnSessionForTopic] Proactive UUID save: ${uuid} for topic ${topicId}`);
+                }
+            }
+            catch (err) {
+                console.error(`[spawnSessionForTopic] Proactive UUID save failed:`, err);
+            }
+        }, 8000);
+    }
     return newSessionName;
 }
 /**
  * Respawn a session for a topic, including thread history in the bootstrap.
  * This prevents "thread drift" where respawned sessions lose context.
  */
-async function respawnSessionForTopic(sessionManager, telegram, targetSession, topicId, latestMessage, topicMemory, userProfile) {
+async function respawnSessionForTopic(sessionManager, telegram, targetSession, topicId, latestMessage, topicMemory, userProfile, recoveryPrompt) {
     console.log(`[telegram→session] Session "${targetSession}" needs respawn for topic ${topicId}`);
     // Save the old session's Claude UUID before respawning so --resume can reattach context
     if (_topicResumeMap) {
@@ -459,7 +480,12 @@ async function respawnSessionForTopic(sessionManager, telegram, targetSession, t
     // Use topic name, not tmux session name — tmux names include the project prefix
     // which causes cascading names like ai-guy-ai-guy-ai-guy-topic-1 on each respawn.
     const topicName = storedName || `topic-${topicId}`;
-    const newSessionName = await spawnSessionForTopic(sessionManager, telegram, topicName, topicId, latestMessage, topicMemory, userProfile);
+    // If this is a recovery respawn, prepend the recovery context to the message
+    // so the session knows what happened and can avoid repeating the failure.
+    const effectiveMessage = recoveryPrompt
+        ? `${recoveryPrompt}\n\n${latestMessage || 'Session recovered — continue where you left off.'}`
+        : latestMessage;
+    const newSessionName = await spawnSessionForTopic(sessionManager, telegram, topicName, topicId, effectiveMessage, topicMemory, userProfile);
     telegram.registerTopicSession(topicId, newSessionName, topicName);
     await telegram.sendToTopic(topicId, `Session respawned.`);
     console.log(`[telegram→session] Respawned "${newSessionName}" for topic ${topicId}`);
@@ -2013,6 +2039,26 @@ export async function startServer(options) {
             resumeHeartbeatInterval.unref();
             console.log(pc.green('  Resume heartbeat: active (60s interval)'));
         }
+        // Save Claude session UUID before any session kill so the topic can be
+        // resumed later with --resume. This fires BEFORE the tmux session is
+        // destroyed, so the UUID can still be discovered from the JSONL mtime.
+        if (_topicResumeMap && telegram) {
+            sessionManager.on('beforeSessionKill', (session) => {
+                try {
+                    const topicId = telegram.getTopicForSession(session.tmuxSession);
+                    if (!topicId)
+                        return;
+                    const uuid = _topicResumeMap.findUuidForSession(session.tmuxSession);
+                    if (uuid) {
+                        _topicResumeMap.save(topicId, uuid, session.tmuxSession);
+                        console.log(`[beforeSessionKill] Saved resume UUID ${uuid} for topic ${topicId} (session: ${session.name})`);
+                    }
+                }
+                catch (err) {
+                    console.error(`[beforeSessionKill] Failed to save resume UUID:`, err);
+                }
+            });
+        }
         if (scheduler) {
             sessionManager.on('sessionComplete', (session) => {
                 scheduler.processQueue();
@@ -2450,6 +2496,25 @@ export async function startServer(options) {
         const { SubagentTracker } = await import('../monitoring/SubagentTracker.js');
         const subagentTracker = new SubagentTracker({ stateDir: config.stateDir });
         console.log(pc.green('  Subagent tracker enabled'));
+        // Wire subagent awareness into zombie cleanup — prevents killing sessions
+        // that are idle at the prompt but waiting for subagent results.
+        const MAX_SUBAGENT_WAIT_MS = 60 * 60_000; // 60 minutes — stale subagent safety cap
+        sessionManager.setSubagentChecker((session) => {
+            if (!session.claudeSessionId)
+                return false;
+            const active = subagentTracker.getActiveSubagents(session.claudeSessionId);
+            if (active.length === 0)
+                return false;
+            // Safety cap: if ALL active subagents have been running > 60 minutes,
+            // treat them as stale (likely missed a SubagentStop event) and allow the kill.
+            const now = Date.now();
+            const allStale = active.every(a => now - new Date(a.startedAt).getTime() > MAX_SUBAGENT_WAIT_MS);
+            if (allStale) {
+                console.warn(`[SessionManager] Session "${session.name}" has ${active.length} stale subagent(s) (>60m). Allowing zombie kill.`);
+                return false;
+            }
+            return true;
+        });
         // Worktree Monitor — detects orphaned worktrees after sessions complete
         const { WorktreeMonitor } = await import('../monitoring/WorktreeMonitor.js');
         const worktreeMonitor = new WorktreeMonitor({