@covibes/zeroshot 1.0.1 → 1.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@covibes/zeroshot",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "Multi-agent orchestration engine for Claude - cluster coordinator and CLI",
   "main": "src/orchestrator.js",
   "bin": {
@@ -75,6 +75,7 @@
     "src/",
     "lib/",
     "cli/",
+    "task-lib/",
     "cluster-templates/",
     "hooks/",
     "docker/",

package/task-lib/attachable-watcher.js

@@ -0,0 +1,202 @@
+#!/usr/bin/env node
+
+/**
+ * Attachable Watcher - spawns Claude with PTY for attach/detach support
+ *
+ * Runs detached from parent, provides Unix socket for attach clients.
+ * Uses node-pty for proper terminal emulation.
+ *
+ * Key differences from legacy watcher.js:
+ * - Uses AttachServer (node-pty) instead of child_process.spawn
+ * - Creates Unix socket at ~/.zeroshot/sockets/task-<id>.sock
+ * - Supports multiple attached clients
+ * - Still writes to log file for backward compatibility
+ */
+
+import { appendFileSync, existsSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { updateTask } from './store.js';
+
+// Import attach infrastructure from src package (CommonJS)
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+const { AttachServer } = require('../src/attach');
+
+// Parse command line args (same format as legacy watcher)
+const [, , taskId, cwd, logFile, argsJson, configJson] = process.argv;
+const args = JSON.parse(argsJson);
+const config = configJson ? JSON.parse(configJson) : {};
+
+// Socket path for attach
+const SOCKET_DIR = join(homedir(), '.zeroshot', 'sockets');
+const socketPath = join(SOCKET_DIR, `${taskId}.sock`);
+
+// Ensure socket directory exists
+if (!existsSync(SOCKET_DIR)) {
+  mkdirSync(SOCKET_DIR, { recursive: true });
+}
+
+function log(msg) {
+  appendFileSync(logFile, msg);
+}
+
+// Build environment - remove API key to force subscription credentials
+const env = { ...process.env };
+delete env.ANTHROPIC_API_KEY;
+
+// Add model flag - priority: config.model > ANTHROPIC_MODEL env var
+const claudeArgs = [...args];
+const model = config.model || env.ANTHROPIC_MODEL;
+if (model && !claudeArgs.includes('--model')) {
+  claudeArgs.unshift('--model', model);
+}
+
+// For JSON schema output with silent mode, track final result
+const silentJsonMode =
+  config.outputFormat === 'json' && config.jsonSchema && config.silentJsonOutput;
+let finalResultJson = null;
+
+// Buffer for incomplete lines
+let outputBuffer = '';
+
+// Create AttachServer to spawn Claude with PTY
+const server = new AttachServer({
+  id: taskId,
+  socketPath,
+  command: 'claude',
+  args: claudeArgs,
+  cwd,
+  env,
+  cols: 120,
+  rows: 30,
+});
+
+// Handle output from PTY
+server.on('output', (data) => {
+  const chunk = data.toString();
+  const timestamp = Date.now();
+
+  if (silentJsonMode) {
+    // Parse each line to find structured_output
+    outputBuffer += chunk;
+    const lines = outputBuffer.split('\n');
+    outputBuffer = lines.pop() || '';
+
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      try {
+        const json = JSON.parse(line);
+        if (json.structured_output) {
+          finalResultJson = line;
+        }
+      } catch {
+        // Not JSON, skip
+      }
+    }
+  } else {
+    // Normal mode - stream with timestamps
+    outputBuffer += chunk;
+    const lines = outputBuffer.split('\n');
+    outputBuffer = lines.pop() || '';
+
+    for (const line of lines) {
+      log(`[${timestamp}]${line}\n`);
+    }
+  }
+});
+
+// Handle process exit
+server.on('exit', ({ exitCode, signal }) => {
+  const timestamp = Date.now();
+  const code = exitCode;
+
+  // Flush remaining buffered output
+  if (outputBuffer.trim()) {
+    if (silentJsonMode) {
+      try {
+        const json = JSON.parse(outputBuffer);
+        if (json.structured_output) {
+          finalResultJson = outputBuffer;
+        }
+      } catch {
+        // Not valid JSON
+      }
+    } else {
+      log(`[${timestamp}]${outputBuffer}\n`);
+    }
+  }
+
+  // In silent JSON mode, log ONLY the final structured_output JSON
+  if (silentJsonMode && finalResultJson) {
+    log(finalResultJson + '\n');
+  }
+
+  // Skip footer for pure JSON output
+  if (config.outputFormat !== 'json') {
+    log(`\n${'='.repeat(50)}\n`);
+    log(`Finished: ${new Date().toISOString()}\n`);
+    log(`Exit code: ${code}, Signal: ${signal}\n`);
+  }
+
+  // Simple status: completed if exit 0, failed otherwise
+  const status = code === 0 ? 'completed' : 'failed';
+  updateTask(taskId, {
+    status,
+    exitCode: code,
+    error: signal ? `Killed by ${signal}` : null,
+    socketPath: null, // Clear socket path on exit
+  });
+
+  // Give clients time to receive exit message before exiting
+  setTimeout(() => {
+    process.exit(0);
+  }, 500);
+});
+
+// Handle errors
+server.on('error', (err) => {
+  log(`\nError: ${err.message}\n`);
+  updateTask(taskId, { status: 'failed', error: err.message });
+  process.exit(1);
+});
+
+// Handle client attach/detach for logging
+server.on('clientAttach', ({ clientId }) => {
+  log(`[${Date.now()}][ATTACH] Client attached: ${clientId.slice(0, 8)}...\n`);
+});
+
+server.on('clientDetach', ({ clientId }) => {
+  log(`[${Date.now()}][DETACH] Client detached: ${clientId.slice(0, 8)}...\n`);
+});
+
+// Start the server
+try {
+  await server.start();
+
+  // Update task with PID and socket path
+  updateTask(taskId, {
+    pid: server.pid,
+    socketPath,
+    attachable: true,
+  });
+
+  log(`[${Date.now()}][SYSTEM] Started with PTY (attachable)\n`);
+  log(`[${Date.now()}][SYSTEM] Socket: ${socketPath}\n`);
+  log(`[${Date.now()}][SYSTEM] PID: ${server.pid}\n`);
+} catch (err) {
+  log(`\nFailed to start: ${err.message}\n`);
+  updateTask(taskId, { status: 'failed', error: err.message });
+  process.exit(1);
+}
+
+// Handle process signals for cleanup
+process.on('SIGTERM', async () => {
+  log(`[${Date.now()}][SYSTEM] Received SIGTERM, stopping...\n`);
+  await server.stop('SIGTERM');
+});
+
+process.on('SIGINT', async () => {
+  log(`[${Date.now()}][SYSTEM] Received SIGINT, stopping...\n`);
+  await server.stop('SIGINT');
+});

package/task-lib/commands/clean.js

@@ -0,0 +1,50 @@
+import { unlinkSync, existsSync } from 'fs';
+import chalk from 'chalk';
+import { loadTasks, saveTasks } from '../store.js';
+
+export function cleanTasks(options = {}) {
+  const tasks = loadTasks();
+  const taskList = Object.values(tasks);
+
+  if (taskList.length === 0) {
+    console.log(chalk.dim('No tasks to clean.'));
+    return;
+  }
+
+  const toRemove = [];
+
+  for (const task of taskList) {
+    const shouldRemove =
+      options.all ||
+      (options.completed && task.status === 'completed') ||
+      (options.failed &&
+        (task.status === 'failed' || task.status === 'stale' || task.status === 'killed'));
+
+    if (shouldRemove) {
+      toRemove.push(task);
+    }
+  }
+
+  if (toRemove.length === 0) {
+    console.log(chalk.dim('No tasks match the criteria.'));
+    return;
+  }
+
+  console.log(chalk.dim(`Removing ${toRemove.length} task(s)...\n`));
+
+  for (const task of toRemove) {
+    // Delete log file
+    if (task.logFile && existsSync(task.logFile)) {
+      unlinkSync(task.logFile);
+    }
+
+    // Remove from tasks
+    delete tasks[task.id];
+
+    console.log(chalk.dim(`  Removed: ${task.id} [${task.status}]`));
+  }
+
+  saveTasks(tasks);
+
+  console.log(chalk.green(`\n✓ Cleaned ${toRemove.length} task(s)`));
+}

package/task-lib/commands/get-log-path.js

@@ -0,0 +1,23 @@
+import { getTask } from '../store.js';
+
+/**
+ * Get log file path for a task (machine-readable output)
+ * Used by cluster/agent-wrapper.js to follow task logs
+ * @param {string} taskId - Task ID
+ */
+export function getLogPath(taskId) {
+  const task = getTask(taskId);
+
+  if (!task) {
+    console.error(`Task not found: ${taskId}`);
+    process.exit(1);
+  }
+
+  if (!task.logFile) {
+    console.error(`No log file for task: ${taskId}`);
+    process.exit(1);
+  }
+
+  // Output just the path (machine-readable)
+  console.log(task.logFile);
+}

package/task-lib/commands/kill.js

@@ -0,0 +1,32 @@
+import chalk from 'chalk';
+import { getTask, updateTask } from '../store.js';
+import { killTask as killProcess, isProcessRunning } from '../runner.js';
+
+export function killTaskCommand(taskId) {
+  const task = getTask(taskId);
+
+  if (!task) {
+    console.log(chalk.red(`Task not found: ${taskId}`));
+    process.exit(1);
+  }
+
+  if (task.status !== 'running') {
+    console.log(chalk.yellow(`Task is not running (status: ${task.status})`));
+    return;
+  }
+
+  if (!isProcessRunning(task.pid)) {
+    console.log(chalk.yellow('Process already dead, updating status...'));
+    updateTask(taskId, { status: 'stale', error: 'Process died unexpectedly' });
+    return;
+  }
+
+  const killed = killProcess(task.pid);
+
+  if (killed) {
+    console.log(chalk.green(`✓ Sent SIGTERM to task ${taskId} (PID: ${task.pid})`));
+    updateTask(taskId, { status: 'killed', error: 'Killed by user' });
+  } else {
+    console.log(chalk.red(`Failed to kill task ${taskId}`));
+  }
+}

package/task-lib/commands/list.js

@@ -0,0 +1,105 @@
+import chalk from 'chalk';
+import { loadTasks } from '../store.js';
+import { isProcessRunning } from '../runner.js';
+
+export function listTasks(options = {}) {
+  const tasks = loadTasks();
+  const taskList = Object.values(tasks);
+
+  if (taskList.length === 0) {
+    console.log(chalk.dim('No tasks found.'));
+    return;
+  }
+
+  // Sort by creation date, newest first
+  taskList.sort((a, b) => new Date(b.createdAt) - new Date(a.createdAt));
+
+  // Filter by status if specified
+  let filtered = taskList;
+  if (options.status) {
+    filtered = taskList.filter((t) => t.status === options.status);
+  }
+
+  // Limit results
+  const limit = options.limit || 20;
+  filtered = filtered.slice(0, limit);
+
+  // Table format (default) or verbose format
+  if (options.verbose) {
+    // Verbose format (old behavior)
+    console.log(chalk.bold(`\nClaude Tasks (${filtered.length}/${taskList.length})\n`));
+
+    for (const task of filtered) {
+      // Verify running status
+      let status = task.status;
+      if (status === 'running' && !isProcessRunning(task.pid)) {
+        status = 'stale';
+      }
+
+      const statusColor =
+        {
+          running: chalk.blue,
+          completed: chalk.green,
+          failed: chalk.red,
+          stale: chalk.yellow,
+        }[status] || chalk.dim;
+
+      const age = getAge(task.createdAt);
+      const timestamp = new Date(task.createdAt).toLocaleString();
+
+      console.log(
+        `${statusColor('●')} ${chalk.cyan(task.id)} ${statusColor(`[${status}]`)} ${chalk.dim(age + ' • ' + timestamp)}`
+      );
+      console.log(`  ${chalk.dim('CWD:')} ${task.cwd}`);
+      console.log(`  ${chalk.dim('Prompt:')} ${task.prompt}`);
+      if (task.pid && status === 'running') {
+        console.log(`  ${chalk.dim('PID:')} ${task.pid}`);
+      }
+      if (task.error) {
+        console.log(`  ${chalk.red('Error:')} ${task.error}`);
+      }
+      console.log();
+    }
+  } else {
+    // Table format (clean, default)
+    console.log(chalk.bold(`\n=== Tasks (${filtered.length}/${taskList.length}) ===`));
+    console.log(`${'ID'.padEnd(25)} ${'Status'.padEnd(12)} ${'Age'.padEnd(10)} CWD`);
+    console.log('-'.repeat(100));
+
+    for (const task of filtered) {
+      // Verify running status
+      let status = task.status;
+      if (status === 'running' && !isProcessRunning(task.pid)) {
+        status = 'stale';
+      }
+
+      const statusColor =
+        {
+          running: chalk.blue,
+          completed: chalk.green,
+          failed: chalk.red,
+          stale: chalk.yellow,
+        }[status] || chalk.dim;
+
+      const age = getAge(task.createdAt);
+      const cwd = task.cwd.replace(process.env.HOME, '~');
+
+      console.log(
+        `${chalk.cyan(task.id.padEnd(25))} ${statusColor(status.padEnd(12))} ${chalk.dim(age.padEnd(10))} ${chalk.dim(cwd)}`
+      );
+    }
+    console.log();
+  }
+}
+
+function getAge(dateStr) {
+  const diff = Date.now() - new Date(dateStr).getTime();
+  const mins = Math.floor(diff / 60000);
+  const hours = Math.floor(mins / 60);
+  const days = Math.floor(hours / 24);
+
+  if (days > 0) return `${days}d ago`;
+  if (hours > 0) return `${hours}h ago`;
+  if (mins > 0) return `${mins}m ago`;
+  return 'just now';
+}