@masslessai/push-todo 3.7.3 → 3.7.5

package/hooks/session-end.js

@@ -2,28 +2,29 @@
 /**
  * Session end hook for Push CLI.
  *
- * Reports session completion status to the backend.
+ * Reports session_finished status to Supabase when a Claude Code session ends.
+ * Reads the active task from ~/.push/active_task.json (written by fetch.js showTask).
+ *
+ * This mirrors the daemon's completion flow: daemon sends session_finished
+ * when its Claude process exits, this hook does the same for foreground sessions.
  */
 
-import { existsSync, readFileSync } from 'fs';
-import { homedir } from 'os';
+import { existsSync, readFileSync, unlinkSync } from 'fs';
+import { homedir, hostname } from 'os';
 import { join } from 'path';
 
 const CONFIG_FILE = join(homedir(), '.config', 'push', 'config');
+const MACHINE_ID_FILE = join(homedir(), '.config', 'push', 'machine_id');
+const ACTIVE_TASK_FILE = join(homedir(), '.push', 'active_task.json');
 const API_BASE = 'https://jxuzqcbqhiaxmfitzxlo.supabase.co/functions/v1';
 
-/**
- * Get the API key from config.
- */
 function getApiKey() {
   if (process.env.PUSH_API_KEY) {
     return process.env.PUSH_API_KEY;
   }
-
   if (!existsSync(CONFIG_FILE)) {
     return null;
   }
-
   try {
     const content = readFileSync(CONFIG_FILE, 'utf8');
     const match = content.match(/^export\s+PUSH_API_KEY\s*=\s*["']?([^"'\n]+)["']?/m);
@@ -33,65 +34,91 @@ function getApiKey() {
   }
 }
 
-/**
- * Get the machine ID.
- */
 function getMachineId() {
-  const machineIdFile = join(homedir(), '.config', 'push', 'machine_id');
-
-  if (existsSync(machineIdFile)) {
+  if (existsSync(MACHINE_ID_FILE)) {
     try {
-      return readFileSync(machineIdFile, 'utf8').trim();
+      return readFileSync(MACHINE_ID_FILE, 'utf8').trim();
     } catch {
       return null;
     }
   }
-
   return null;
 }
 
-/**
- * Report session end to backend.
- */
-async function reportSessionEnd(apiKey, machineId, exitReason) {
+function getActiveTask() {
+  if (!existsSync(ACTIVE_TASK_FILE)) {
+    return null;
+  }
+  try {
+    return JSON.parse(readFileSync(ACTIVE_TASK_FILE, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function clearActiveTask() {
+  try {
+    if (existsSync(ACTIVE_TASK_FILE)) {
+      unlinkSync(ACTIVE_TASK_FILE);
+    }
+  } catch {
+    // Ignore cleanup errors
+  }
+}
+
+async function reportSessionFinished(apiKey, activeTask) {
+  const machineId = getMachineId();
+  const machineName = hostname();
+  const startedAt = activeTask.startedAt ? new Date(activeTask.startedAt) : null;
+  const now = new Date();
+
+  const durationMs = startedAt ? now.getTime() - startedAt.getTime() : null;
+  const durationStr = durationMs
+    ? `${Math.floor(durationMs / 60000)}m ${Math.floor((durationMs % 60000) / 1000)}s`
+    : null;
+
+  const payload = {
+    displayNumber: activeTask.displayNumber,
+    status: 'session_finished',
+    machineId,
+    machineName,
+    event: {
+      type: 'session_finished',
+      timestamp: now.toISOString(),
+      machineName: machineName || undefined,
+      summary: durationStr
+        ? `Foreground session ended (${durationStr})`
+        : 'Foreground session ended',
+    },
+  };
+
   try {
-    const response = await fetch(`${API_BASE}/session-end`, {
-      method: 'POST',
+    const response = await fetch(`${API_BASE}/update-task-execution`, {
+      method: 'PATCH',
       headers: {
         'Authorization': `Bearer ${apiKey}`,
-        'Content-Type': 'application/json'
+        'Content-Type': 'application/json',
       },
-      body: JSON.stringify({
-        machine_id: machineId,
-        exit_reason: exitReason,
-        timestamp: new Date().toISOString()
-      }),
-      signal: AbortSignal.timeout(10000)
+      body: JSON.stringify(payload),
+      signal: AbortSignal.timeout(10000),
     });
-
     return response.ok;
   } catch {
     return false;
   }
 }
 
-/**
- * Main entry point.
- */
 async function main() {
   const apiKey = getApiKey();
-  const machineId = getMachineId();
+  const activeTask = getActiveTask();
 
-  if (!apiKey || !machineId) {
-    // Not configured - silent exit
+  if (!apiKey || !activeTask) {
+    // Not configured or no active task — silent exit
     process.exit(0);
   }
 
-  // Get exit reason from environment (Claude Code may set this)
-  const exitReason = process.env.CLAUDE_EXIT_REASON || 'normal';
-
-  // Report to backend
-  await reportSessionEnd(apiKey, machineId, exitReason);
+  await reportSessionFinished(apiKey, activeTask);
+  clearActiveTask();
 
   process.exit(0);
 }

package/lib/api.js

@@ -229,7 +229,7 @@ export async function searchTasks(query, gitRemote = null) {
  */
 export async function updateTaskExecution(payload) {
   const response = await apiRequest('update-task-execution', {
-    method: 'POST',
+    method: 'PATCH',
     body: JSON.stringify(payload)
   });
 

package/lib/config.js

@@ -150,6 +150,48 @@ export function setAutoCommitEnabled(enabled) {
   return setConfigValue('AUTO_COMMIT', enabled ? 'true' : 'false');
 }
 
+/**
+ * Check if auto-merge into main is enabled after daemon task completion.
+ * Default: true (merge PR into main after session_finished)
+ *
+ * @returns {boolean}
+ */
+export function getAutoMergeEnabled() {
+  const value = getConfigValue('AUTO_MERGE', 'true');
+  return value.toLowerCase() === 'true' || value === '1' || value.toLowerCase() === 'yes';
+}
+
+/**
+ * Set auto-merge setting.
+ *
+ * @param {boolean} enabled
+ * @returns {boolean} True if successful
+ */
+export function setAutoMergeEnabled(enabled) {
+  return setConfigValue('AUTO_MERGE', enabled ? 'true' : 'false');
+}
+
+/**
+ * Check if auto-complete is enabled after daemon task merge.
+ * Default: true (mark task as completed after successful merge)
+ *
+ * @returns {boolean}
+ */
+export function getAutoCompleteEnabled() {
+  const value = getConfigValue('AUTO_COMPLETE', 'true');
+  return value.toLowerCase() === 'true' || value === '1' || value.toLowerCase() === 'yes';
+}
+
+/**
+ * Set auto-complete setting.
+ *
+ * @param {boolean} enabled
+ * @returns {boolean} True if successful
+ */
+export function setAutoCompleteEnabled(enabled) {
+  return setConfigValue('AUTO_COMPLETE', enabled ? 'true' : 'false');
+}
+
 /**
  * Get the maximum batch size for queuing tasks.
  * Default: 5
@@ -226,16 +268,24 @@ export function showSettings() {
   console.log();
 
   const autoCommit = getAutoCommitEnabled();
+  const autoMerge = getAutoMergeEnabled();
+  const autoComplete = getAutoCompleteEnabled();
   const batchSize = getMaxBatchSize();
 
-  console.log(`  auto-commit:  ${autoCommit ? 'ON' : 'OFF'}`);
-  console.log('                Auto-commit when task completes');
+  console.log(`  auto-commit:    ${autoCommit ? 'ON' : 'OFF'}`);
+  console.log('                  Auto-commit when task completes');
+  console.log();
+  console.log(`  auto-merge:     ${autoMerge ? 'ON' : 'OFF'}`);
+  console.log('                  Merge PR into main after daemon task finishes');
   console.log();
-  console.log(`  batch-size:   ${batchSize}`);
-  console.log('                Max tasks for batch queue (1-20)');
+  console.log(`  auto-complete:  ${autoComplete ? 'ON' : 'OFF'}`);
+  console.log('                  Mark task completed after successful merge');
+  console.log();
+  console.log(`  batch-size:     ${batchSize}`);
+  console.log('                  Max tasks for batch queue (1-20)');
   console.log();
   console.log('  Toggle with: push-todo setting <name>');
-  console.log('  Example:     push-todo setting auto-commit');
+  console.log('  Example:     push-todo setting auto-merge');
   console.log();
 }
 
@@ -264,6 +314,38 @@ export function toggleSetting(settingName) {
     return false;
   }
 
+  if (normalized === 'auto-merge') {
+    const current = getAutoMergeEnabled();
+    const newValue = !current;
+    if (setAutoMergeEnabled(newValue)) {
+      console.log(`Auto-merge is now ${newValue ? 'ON' : 'OFF'}`);
+      if (newValue) {
+        console.log('PRs will be merged into main after daemon task finishes.');
+      } else {
+        console.log('PRs will NOT be merged automatically.');
+      }
+      return true;
+    }
+    console.error('Failed to update setting');
+    return false;
+  }
+
+  if (normalized === 'auto-complete') {
+    const current = getAutoCompleteEnabled();
+    const newValue = !current;
+    if (setAutoCompleteEnabled(newValue)) {
+      console.log(`Auto-complete is now ${newValue ? 'ON' : 'OFF'}`);
+      if (newValue) {
+        console.log('Tasks will be marked completed after successful merge.');
+      } else {
+        console.log('Tasks will NOT be marked completed automatically.');
+      }
+      return true;
+    }
+    console.error('Failed to update setting');
+    return false;
+  }
+
   if (normalized === 'batch-size') {
     const batchSize = getMaxBatchSize();
     console.log(`Current batch size: ${batchSize}`);
@@ -272,7 +354,7 @@ export function toggleSetting(settingName) {
   }
 
   console.error(`Unknown setting: ${settingName}`);
-  console.error('Available settings: auto-commit, batch-size');
+  console.error('Available settings: auto-commit, auto-merge, auto-complete, batch-size');
   return false;
 }
 

package/lib/daemon.js

@@ -199,6 +199,37 @@ function getVersion() {
   }
 }
 
+function getConfigValueFromFile(key, defaultValue = '') {
+  const fullKey = `PUSH_${key}`;
+  if (!existsSync(CONFIG_FILE)) return defaultValue;
+  try {
+    const content = readFileSync(CONFIG_FILE, 'utf8');
+    for (const line of content.split('\n')) {
+      const trimmed = line.trim();
+      if (trimmed.startsWith(`export ${fullKey}=`)) {
+        let value = trimmed.split('=')[1] || '';
+        value = value.trim();
+        if ((value.startsWith('"') && value.endsWith('"')) ||
+            (value.startsWith("'") && value.endsWith("'"))) {
+          value = value.slice(1, -1);
+        }
+        return value;
+      }
+    }
+  } catch {}
+  return defaultValue;
+}
+
+function getAutoMergeEnabled() {
+  const v = getConfigValueFromFile('AUTO_MERGE', 'true');
+  return v.toLowerCase() === 'true' || v === '1' || v.toLowerCase() === 'yes';
+}
+
+function getAutoCompleteEnabled() {
+  const v = getConfigValueFromFile('AUTO_COMPLETE', 'true');
+  return v.toLowerCase() === 'true' || v === '1' || v.toLowerCase() === 'yes';
+}
+
 // ==================== E2EE Decryption ====================
 
 let decryptTodoField = null;
@@ -596,6 +627,83 @@ Automated PR from Push daemon for task #${displayNumber}.
   }
 }
 
+/**
+ * Merge a PR into main and update local main branch.
+ * Uses `gh pr merge` for clean remote merge, then pulls locally.
+ *
+ * @returns {boolean} True if merge succeeded
+ */
+function mergePRForTask(displayNumber, prUrl, projectPath) {
+  const gitCwd = projectPath || process.cwd();
+
+  // Extract PR number from URL (e.g., https://github.com/user/repo/pull/42)
+  const prMatch = prUrl.match(/\/pull\/(\d+)/);
+  if (!prMatch) {
+    logError(`Could not extract PR number from: ${prUrl}`);
+    return false;
+  }
+  const prNumber = prMatch[1];
+
+  try {
+    execFileSync('gh', ['pr', 'merge', prNumber, '--merge', '--delete-branch'], {
+      cwd: gitCwd,
+      timeout: 60000,
+      stdio: 'pipe'
+    });
+    log(`Merged PR #${prNumber} for task #${displayNumber}`);
+
+    // Pull main locally so next worktree is up to date
+    try {
+      execFileSync('git', ['pull', '--ff-only'], {
+        cwd: gitCwd,
+        timeout: 30000,
+        stdio: 'pipe'
+      });
+      log('Updated local main branch');
+    } catch {
+      log('Could not pull main (may not be checked out), skipping local update');
+    }
+
+    return true;
+  } catch (e) {
+    const stderr = e.stderr?.toString() || e.message || '';
+    if (stderr.includes('merge conflict') || stderr.includes('conflict')) {
+      logError(`PR #${prNumber} has merge conflicts, skipping auto-merge`);
+    } else if (stderr.includes('not found') || stderr.includes('ENOENT')) {
+      log('GitHub CLI (gh) not installed, skipping merge');
+    } else {
+      logError(`Failed to merge PR #${prNumber}: ${stderr.slice(0, 200)}`);
+    }
+    return false;
+  }
+}
+
+/**
+ * Mark a task as completed via the todo-status endpoint.
+ */
+async function markTaskAsCompleted(displayNumber, taskId, comment) {
+  try {
+    const response = await apiRequest('todo-status', {
+      method: 'PATCH',
+      body: JSON.stringify({
+        todoId: taskId,
+        isCompleted: true,
+        completedAt: new Date().toISOString(),
+        completionComment: comment || `Completed by daemon on ${getMachineName()}`
+      })
+    });
+    if (response.ok) {
+      log(`Task #${displayNumber} marked as completed`);
+      return true;
+    }
+    logError(`Failed to mark #${displayNumber} complete: HTTP ${response.status}`);
+    return false;
+  } catch (error) {
+    logError(`Failed to mark #${displayNumber} complete: ${error.message}`);
+    return false;
+  }
+}
+
 // ==================== Stuck Detection ====================
 
 function checkStuckPatterns(displayNumber, line) {
@@ -1000,12 +1108,27 @@ function handleTaskCompletion(displayNumber, exitCode) {
       );
     }
 
+    // Auto-merge PR into main (configurable, default ON)
+    let merged = false;
+    if (getAutoMergeEnabled() && prUrl) {
+      merged = mergePRForTask(displayNumber, prUrl, projectPath);
+    }
+
+    // Auto-complete task after successful merge (configurable, default ON)
+    const taskId = info.taskId;
+    if (getAutoCompleteEnabled() && merged && taskId) {
+      const comment = semanticSummary
+        ? `${semanticSummary} (${durationStr} on ${machineName})`
+        : `Completed in ${durationStr} on ${machineName}`;
+      markTaskAsCompleted(displayNumber, taskId, comment);
+    }
+
     completedToday.push({
       displayNumber,
       summary,
       completedAt: new Date().toISOString(),
       duration,
-      status: 'session_finished',
+      status: merged ? 'completed' : 'session_finished',
       prUrl,
       sessionId
     });

package/lib/fetch.js

@@ -12,6 +12,9 @@ import { formatTaskForDisplay, formatSearchResult } from './utils/format.js';
 import { bold, green, yellow, red, cyan, dim, muted } from './utils/colors.js';
 import { decryptTodoField, isE2EEAvailable } from './encryption.js';
 import { getAutoCommitEnabled, getMaxBatchSize } from './config.js';
+import { writeFileSync, mkdirSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
 
 /**
  * Decrypt encrypted fields in a task object.
@@ -121,7 +124,7 @@ export async function listTasks(options = {}) {
   if (!options.backlog && !options.completed && running.length > 0) {
     console.log(`# ${running.length} Running/Queued Tasks (${scope})\n`);
     for (const task of running) {
-      const displayNum = task.displayNumber || task.display_number;
+      const displayNum = task.displayNumber;
       console.log(`---\n### #${displayNum}\n`);
       console.log(formatTaskForDisplay(task));
       console.log('');
@@ -134,7 +137,7 @@ export async function listTasks(options = {}) {
 
   // Show full details for each task (matching Python behavior)
   for (const task of tasksToShow) {
-    const displayNum = task.displayNumber || task.display_number;
+    const displayNum = task.displayNumber;
     console.log(`---\n### #${displayNum}\n`);
     console.log(formatTaskForDisplay(task));
     console.log('');
@@ -183,6 +186,49 @@ export async function showTask(displayNumber, options = {}) {
   }
 
   console.log(formatTaskForDisplay(decrypted));
+
+  // Track active task for session-end hook and send running status to Supabase.
+  // Skip if task is already running or queued (daemon owns it).
+  const execStatus = decrypted.executionStatus;
+  if (execStatus !== 'running' && execStatus !== 'queued') {
+    trackActiveTask(decrypted).catch(() => {});
+  }
+}
+
+/**
+ * Track active task for foreground execution.
+ *
+ * Mirrors the daemon's behavior: sends 'running' status to Supabase
+ * and writes ~/.push/active_task.json for the session-end hook.
+ *
+ * @param {Object} task - Task object from API
+ */
+async function trackActiveTask(task) {
+  const pushDir = join(homedir(), '.push');
+  mkdirSync(pushDir, { recursive: true });
+
+  // Write active task file for session-end hook to read
+  writeFileSync(join(pushDir, 'active_task.json'), JSON.stringify({
+    displayNumber: task.displayNumber,
+    taskId: task.id,
+    startedAt: new Date().toISOString(),
+  }));
+
+  // Send running status to Supabase (same as daemon's updateTaskStatus)
+  const machineId = getMachineId();
+  const machineName = getMachineName();
+  await api.updateTaskExecution({
+    displayNumber: task.displayNumber,
+    status: 'running',
+    machineId,
+    machineName,
+    event: {
+      type: 'started',
+      timestamp: new Date().toISOString(),
+      machineName: machineName || undefined,
+      summary: 'Foreground session started',
+    },
+  });
 }
 
 /**
@@ -432,7 +478,7 @@ export async function runReview(options = {}) {
 
   // Show full details for each task (matching Python behavior)
   for (const task of decrypted) {
-    const displayNum = task.displayNumber || task.display_number;
+    const displayNum = task.displayNumber;
     console.log(`---\n### #${displayNum}\n`);
     console.log(formatTaskForDisplay(task));
     console.log('');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@masslessai/push-todo",
-  "version": "3.7.3",
+  "version": "3.7.5",
   "description": "Voice tasks from Push iOS app for Claude Code",
   "type": "module",
   "bin": {