create-walle 0.9.21 → 0.9.23

package/template/claude-task-manager/lib/agent-capabilities.js

@@ -37,6 +37,18 @@ const AGENT_CAPABILITIES = Object.freeze({
     resume: true,
     resumeSpec: (id) => ({ cmd: 'gemini', args: ['--session', id] }),
   }),
+  opencode: Object.freeze({
+    agentType: 'opencode',
+    providerId: 'opencode',
+    label: 'OpenCode',
+    liveStatus: true,
+    stateDetector: true,
+    structuredTranscript: false,
+    promptNavigation: 'terminal',
+    review: false,
+    resume: false,
+    resumeSpec: () => null,
+  }),
   walle: Object.freeze({
     agentType: 'walle',
     providerId: 'walle',
@@ -49,6 +61,23 @@ const AGENT_CAPABILITIES = Object.freeze({
     resume: false,
     resumeSpec: () => null,
   }),
+  cursor: Object.freeze({
+    agentType: 'cursor',
+    providerId: 'cursor',
+    label: 'Cursor',
+    liveStatus: true,
+    stateDetector: true,
+    structuredTranscript: false,
+    promptNavigation: 'terminal',
+    review: false,
+    resume: true,
+    // Cursor chats are cloud-backed: there's no local transcript (JSONL/SQLite)
+    // under ~/.cursor or ~/.local/share/cursor-agent that CTM can tail, so we
+    // never capture a concrete chatId. Targeted resume would need Cursor's
+    // cloud API. Fall back to `cursor-agent --resume` with no id, which opens
+    // Cursor's own session picker — the working resume path today.
+    resumeSpec: (id) => ({ cmd: 'cursor-agent', args: id ? ['--resume', id] : ['--resume'] }),
+  }),
   shell: Object.freeze({
     agentType: 'shell',
     providerId: 'shell',
@@ -69,6 +98,8 @@ function detectAgentType(cmd) {
   if (s.includes('claude')) return 'claude';
   if (s.includes('codex')) return 'codex';
   if (s.includes('gemini')) return 'gemini';
+  if (s.includes('opencode') || s.includes('open-code')) return 'opencode';
+  if (s.includes('cursor')) return 'cursor';
   if (s === 'walle' || s.includes('wall-e') || s.includes('walle')) return 'walle';
   return null;
 }
@@ -79,6 +110,8 @@ function normalizeAgentType(value) {
   if (AGENT_CAPABILITIES[s]) return s;
   if (s === 'claude-code') return 'claude';
   if (s === 'gemini-cli') return 'gemini';
+  if (s === 'opencode-cli' || s === 'open-code') return 'opencode';
+  if (s === 'cursor-agent' || s === 'cursor-cli') return 'cursor';
   return detectAgentType(s);
 }
 

package/template/claude-task-manager/lib/agent-cli-cache.js

@@ -6,7 +6,7 @@ const path = require('path');
 const crypto = require('crypto');
 
 const CACHE_VERSION = 1;
-const DEFAULT_AGENTS = Object.freeze(['claude', 'codex', 'gemini']);
+const DEFAULT_AGENTS = Object.freeze(['claude', 'codex', 'gemini', 'cursor-agent']);
 
 function _pathHash(envPath) {
   return crypto.createHash('sha256').update(String(envPath || '')).digest('hex');
@@ -19,6 +19,34 @@ function _splitPath(envPath) {
     .filter(Boolean);
 }
 
+// GUI-launched processes (e.g. the packaged "Coding Task Manager" app) inherit
+// a minimal PATH that often omits user-local install dirs. cursor-agent (and
+// the cursor/claude/codex installers) drop binaries in ~/.local/bin, so a CLI
+// installed only there would read as "not detected on PATH" even though it
+// works in a normal shell. Always probe these well-known dirs in addition to
+// the process PATH so detection — and the absolute-path resolution that powers
+// spawning — are independent of how CTM was launched.
+function _extraBinDirs() {
+  const home = os.homedir();
+  if (!home) return ['/opt/homebrew/bin', '/usr/local/bin'];
+  return [
+    path.join(home, '.local', 'bin'),
+    path.join(home, 'bin'),
+    '/opt/homebrew/bin',
+    '/usr/local/bin',
+  ];
+}
+
+function _candidateBinDirs(envPath, extraDirs) {
+  const extras = Array.isArray(extraDirs) ? extraDirs : _extraBinDirs();
+  const seen = new Set();
+  const dirs = [];
+  for (const dir of [..._splitPath(envPath), ...extras]) {
+    if (dir && !seen.has(dir)) { seen.add(dir); dirs.push(dir); }
+  }
+  return dirs;
+}
+
 function _isExecutable(filePath) {
   try {
     fs.accessSync(filePath, fs.constants.X_OK);
@@ -76,8 +104,8 @@ function _sameFingerprint(a, b) {
     a.lstat?.ctimeMs === b.lstat?.ctimeMs;
 }
 
-function _findOnPath(bin, envPath) {
-  for (const dir of _splitPath(envPath)) {
+function _findOnPath(bin, envPath, extraDirs) {
+  for (const dir of _candidateBinDirs(envPath, extraDirs)) {
     const candidate = path.resolve(dir, bin);
     const fingerprint = _statFingerprint(candidate);
     if (fingerprint) return fingerprint;
@@ -135,9 +163,9 @@ function _publicEntry(entry, envPath) {
   };
 }
 
-function discoverAgent(agent, { env = process.env, now = Date.now() } = {}) {
+function discoverAgent(agent, { env = process.env, now = Date.now(), extraBinDirs } = {}) {
   const envPath = env.PATH || process.env.PATH || '';
-  return _entryFromFingerprint(agent, _findOnPath(agent, envPath), envPath, now, 'path-scan');
+  return _entryFromFingerprint(agent, _findOnPath(agent, envPath, extraBinDirs), envPath, now, 'path-scan');
 }
 
 function getAvailableAgents({
@@ -145,6 +173,7 @@ function getAvailableAgents({
   agents = DEFAULT_AGENTS,
   env = process.env,
   now = Date.now(),
+  extraBinDirs,
 } = {}) {
   const envPath = env.PATH || process.env.PATH || '';
   const cache = _readCache(cacheFile);
@@ -160,7 +189,7 @@ function getAvailableAgents({
     const cached = cache.agents[agent];
     let entry = cached;
     if (!_isCachedEntryFresh(cached, envPath)) {
-      entry = discoverAgent(agent, { env, now });
+      entry = discoverAgent(agent, { env, now, extraBinDirs });
       cache.agents[agent] = entry;
       changed = true;
     }
@@ -197,6 +226,7 @@ function resolveCliCommand(cmd, {
   agents = DEFAULT_AGENTS,
   env = process.env,
   now = Date.now(),
+  extraBinDirs,
 } = {}) {
   if (!cmd || typeof cmd !== 'string') return cmd;
   const base = path.basename(cmd);
@@ -206,7 +236,7 @@ function resolveCliCommand(cmd, {
   // a persisted CTM task points at a removed CLI path, recover via PATH.
   if (cmd.includes('/') && _statFingerprint(cmd)) return cmd;
 
-  const available = getAvailableAgents({ cacheFile, agents, env, now });
+  const available = getAvailableAgents({ cacheFile, agents, env, now, extraBinDirs });
   const entry = available.agents[base];
   return entry?.available && entry.path ? entry.path : cmd;
 }

package/template/claude-task-manager/lib/agent-hooks-installer.js

@@ -7,6 +7,11 @@
 //   2. ~/.codex/config.toml     — [otel] block + [notify] block (custom TOML parser)
 //   3. ~/.gemini/settings.json  — JSON hooks that run our bin/gemini-hook.js
 //
+// Cursor is also a first-class coding-agent runtime, but it does not currently
+// expose a documented hook config surface. Its live status comes from CTM's
+// managed terminal lifecycle, so install/uninstall are no-op plans instead of
+// writing speculative keys into ~/.cursor/cli-config.json.
+//
 // Every write is idempotent: re-running install() is a no-op if the marker
 // strings (identifying our hook entries) are already present. uninstall()
 // removes only our entries and leaves everything else intact.
@@ -46,6 +51,20 @@ function ctmMarker(port) {
   return `ctm:${port}:${HOOK_BIN_DIR}`;
 }
 
+function planTerminalManagedAgent(agent, preset) {
+  return {
+    agent,
+    filePath: expandHome(preset?.configPath || ''),
+    format: preset?.configFormat || 'none',
+    currentText: '',
+    nextText: '',
+    willWrite: false,
+    changes: [
+      { description: 'No config write: CTM tracks this runtime through the managed terminal lifecycle.' },
+    ],
+  };
+}
+
 // ─── Claude settings.json (JSON, array-of-hooks shape) ────────────────────
 
 /**
@@ -61,8 +80,9 @@ function safeReadFile(p) {
   if (!fs.existsSync(p)) return '';
   try { return fs.readFileSync(p, 'utf8'); }
   catch (e) {
-    const hint = (e.code === 'EDEADLK' || /deadlock/i.test(e.message))
-      ? ' (file appears to be a cloud-storage placeholder — click the file in Finder to materialize it, then retry)'
+    const materializeProblem = e.code === 'EDEADLK' || e.errno === -11 || /deadlock|system error -11/i.test(e.message || '');
+    const hint = materializeProblem
+      ? ' (file appears to be a cloud-storage placeholder or dataless file — make it available offline, then retry)'
       : '';
     throw new Error(`cannot read ${p}: ${e.message}${hint}`);
   }
@@ -393,6 +413,7 @@ function unpatchCodexConfig(text, _port) {
 function planInstall(agent, port) {
   const preset = getPreset(agent);
   if (!preset) throw new Error(`Unknown agent preset: ${agent}`);
+  if (preset.liveStatusMode === 'terminal') return planTerminalManagedAgent(agent, preset);
   if (agent === 'claude-code') {
     const { __path, data, rawText } = readClaudeSettings();
     const next = patchClaudeSettings(data, port);
@@ -438,6 +459,7 @@ function planInstall(agent, port) {
 function planUninstall(agent, port) {
   const preset = getPreset(agent);
   if (!preset) throw new Error(`Unknown agent preset: ${agent}`);
+  if (preset.liveStatusMode === 'terminal') return planTerminalManagedAgent(agent, preset);
   if (agent === 'claude-code') {
     const { __path, data, rawText } = readClaudeSettings();
     const next = unpatchClaudeSettings(data, port);
@@ -481,6 +503,8 @@ function uninstall(agent, port) { return applyPlan(planUninstall(agent, port));
 
 /** Is this agent's config currently patched with our marker (for this port)? */
 function isInstalled(agent, port) {
+  const preset = getPreset(agent);
+  if (preset?.liveStatusMode === 'terminal') return true;
   const marker = ctmMarker(port);
   try {
     if (agent === 'claude-code') {

package/template/claude-task-manager/lib/agent-presets.js

@@ -13,8 +13,9 @@
  * @property {Object}  [telemetryEnv] - env vars to set when spawning this agent. Values may
  *                                      contain "{{port}}" which will be replaced at spawn
  *                                      time with the CTM HTTP port.
- * @property {string}  [configPath]  - path to the agent's user config file (for hook install)
+ * @property {string}  [configPath]  - path to the agent's user config file (for hook install/status context)
  * @property {'json' | 'toml'} [configFormat] - format of the config file (informs the patcher)
+ * @property {'hooks' | 'terminal'} [liveStatusMode] - how CTM gets live status for this runtime
  * @property {Array<{ kind: string, matcher: string|null, bin: string, route: string }>} [hooks]
  *   Hooks to install into the agent's config.
  *     kind    — agent-specific event name ("Stop", "SessionStart", etc.)
@@ -40,6 +41,7 @@ const PRESETS = {
     },
     configPath: '~/.claude/settings.json',
     configFormat: 'json',
+    liveStatusMode: 'hooks',
     hooks: [
       { kind: 'SessionStart',     matcher: null, bin: 'claude-hook', route: 'start' },
       { kind: 'UserPromptSubmit', matcher: null, bin: 'claude-hook', route: 'start' },
@@ -62,6 +64,7 @@ const PRESETS = {
     },
     configPath: '~/.codex/config.toml',
     configFormat: 'toml',
+    liveStatusMode: 'hooks',
     hooks: [
       // [notify] block handler; patcher writes this differently than Claude's hooks.
       { kind: 'notify', matcher: null, bin: 'codex-notify', route: 'stop' },
@@ -76,6 +79,7 @@ const PRESETS = {
     // No OTEL env — state flows through hooks only.
     configPath: '~/.gemini/settings.json',
     configFormat: 'json',
+    liveStatusMode: 'hooks',
     hooks: [
       { kind: 'BeforeAgent', matcher: null, bin: 'gemini-hook', route: 'start' },
       { kind: 'AfterAgent',  matcher: null, bin: 'gemini-hook', route: 'stop'  },
@@ -83,6 +87,18 @@ const PRESETS = {
       { kind: 'BeforeTool',  matcher: null, bin: 'gemini-hook', route: 'menu'  },
     ],
   },
+  'cursor': {
+    presetId: 'cursor',
+    name: 'Cursor',
+    commandRegex: /(^|\/)cursor-agent(\s|$)/,
+    // Cursor Agent CLI does not currently expose a documented settings hook
+    // contract like Claude/Codex/Gemini. CTM still owns reliable live status
+    // for Cursor sessions it launches through the managed PTY lifecycle.
+    configPath: '~/.cursor/cli-config.json',
+    configFormat: 'json',
+    liveStatusMode: 'terminal',
+    hooks: [],
+  },
 };
 
 /** Detect which preset applies to a given spawn command (same contract as server.js's detectAgentType). */

package/template/claude-task-manager/lib/all-sessions-query.js

@@ -0,0 +1,108 @@
+'use strict';
+
+// Shared "all sessions" read query. Extracted from db.getAllSessionsData() so the
+// SAME logic runs both on the main thread (db.js, via the live connection) AND on the
+// read-pool worker (via a read-only connection) — keeping the recent-sessions rebuild
+// off the main event loop (opportunity A follow-up). It is a pure read (two window-
+// function queries + an in-memory join), so it is safe to run on a read-only WAL
+// connection in a worker. Takes the database handle as a parameter — no module-level
+// connection — so neither caller can accidentally diverge from the other.
+
+function _columnSet(d, table) {
+  try {
+    return new Set(d.prepare(`PRAGMA table_info(${table})`).all().map(c => c.name));
+  } catch {
+    return new Set();
+  }
+}
+
+function queryAllSessionsData(d) {
+  const scCols = _columnSet(d, 'session_conversations');
+  const scLastMessageAt = scCols.has('last_message_at') ? 'sc.last_message_at' : "''";
+  const rows = d.prepare(`
+    SELECT c.*, a.agent_session_id, a.provider_resume_id, a.jsonl_path, a.first_message, a.file_size,
+      a.modified_at, a.hostname, a.model, a.git_branch,
+      a.thread_source, a.parent_agent_session_id, a.agent_nickname, a.agent_role,
+      COALESCE(agent_list.agent_session_ids, '') as agent_session_ids,
+      COALESCE(agent_list.agent_session_count, 0) as agent_session_count,
+      MAX(COALESCE(a.user_msg_count, 0), COALESCE(sc.user_msg_count, 0)) as user_msg_count,
+      COALESCE(NULLIF(a.last_user_content, ''), sc.last_user_content) as last_user_content,
+      COALESCE(NULLIF(a.first_assistant_text, ''), sc.first_assistant_text) as first_assistant_text,
+      COALESCE(NULLIF(a.rename_name, ''), sc.rename_name) as rename_name,
+      COALESCE(NULLIF(${scLastMessageAt}, ''), '') as last_message_at
+    FROM ctm_sessions c
+    LEFT JOIN (
+      SELECT *, ROW_NUMBER() OVER (
+        PARTITION BY ctm_session_id
+        ORDER BY COALESCE(NULLIF(modified_at, ''), updated_at, created_at) DESC,
+          updated_at DESC,
+          created_at DESC
+      ) as rn
+      FROM agent_sessions
+    ) a ON a.ctm_session_id = c.id AND a.rn = 1
+    LEFT JOIN (
+      SELECT ctm_session_id,
+        group_concat(agent_session_id, ',') as agent_session_ids,
+        COUNT(*) as agent_session_count
+      FROM (
+        SELECT ctm_session_id, agent_session_id
+        FROM agent_sessions
+        ORDER BY COALESCE(NULLIF(modified_at, ''), updated_at, created_at) DESC,
+          updated_at DESC,
+          created_at DESC
+      ) ordered_agents
+      GROUP BY ctm_session_id
+    ) agent_list ON agent_list.ctm_session_id = c.id
+    LEFT JOIN session_conversations sc ON sc.ctm_session_id = a.agent_session_id
+  `).all();
+
+  const agentRows = d.prepare(`
+    SELECT
+      a.agent_session_id,
+      a.ctm_session_id,
+      a.provider,
+      a.provider_resume_id,
+      a.project_path,
+      a.jsonl_path,
+      COALESCE(NULLIF(a.first_message, ''), sc.first_message) as first_message,
+      a.file_size,
+      a.modified_at,
+      a.hostname,
+      COALESCE(NULLIF(a.model, ''), sc.model_id) as model,
+      sc.model_provider as model_provider,
+      COALESCE(NULLIF(a.git_branch, ''), sc.git_branch) as git_branch,
+      MAX(COALESCE(a.user_msg_count, 0), COALESCE(sc.user_msg_count, 0)) as user_msg_count,
+      a.slug,
+      a.thread_source,
+      a.parent_agent_session_id,
+      a.agent_nickname,
+      a.agent_role,
+      a.created_at,
+      a.updated_at,
+      COALESCE(NULLIF(a.last_user_content, ''), sc.last_user_content) as last_user_content,
+      COALESCE(NULLIF(a.first_assistant_text, ''), sc.first_assistant_text) as first_assistant_text,
+      COALESCE(NULLIF(a.rename_name, ''), sc.rename_name) as rename_name,
+      COALESCE(NULLIF(${scLastMessageAt}, ''), '') as last_message_at
+    FROM agent_sessions a
+    LEFT JOIN session_conversations sc ON sc.ctm_session_id = a.agent_session_id
+    ORDER BY
+      a.ctm_session_id ASC,
+      COALESCE(NULLIF(a.modified_at, ''), a.updated_at, a.created_at) DESC,
+      a.created_at DESC
+  `).all();
+
+  const byCtmId = new Map();
+  for (const agent of agentRows) {
+    if (!agent.ctm_session_id) continue;
+    if (!byCtmId.has(agent.ctm_session_id)) byCtmId.set(agent.ctm_session_id, []);
+    byCtmId.get(agent.ctm_session_id).push(agent);
+  }
+
+  for (const row of rows) {
+    row.agent_sessions = byCtmId.get(row.id) || [];
+    row.agent_session_count = row.agent_sessions.length;
+  }
+  return rows;
+}
+
+module.exports = { queryAllSessionsData };