create-walle 0.9.11 → 0.9.13

package/template/wall-e/adapters/ctm.js

@@ -1,13 +1,19 @@
 const fs = require('fs');
 const path = require('path');
 const AdapterBase = require('./adapter-base');
+const claudeDesktopSessions = require('../../claude-task-manager/lib/claude-desktop-sessions');
 
 const MAX_FILE_SIZE = 50 * 1024 * 1024; // 50MB — skip files larger than this
 
 class CtmAdapter extends AdapterBase {
-  constructor({ projectsDir } = {}) {
+  constructor({ projectsDir, desktopAppSupportDirs, includeClaudeDesktop } = {}) {
     super('ctm');
+    const hasCustomProjectsDir = !!projectsDir;
     this.projectsDir = projectsDir || path.join(process.env.HOME, '.claude', 'projects');
+    this.desktopAppSupportDirs = desktopAppSupportDirs || null;
+    this.includeClaudeDesktop = includeClaudeDesktop !== undefined
+      ? includeClaudeDesktop
+      : (!hasCustomProjectsDir || !!desktopAppSupportDirs);
     this._processedFiles = new Map(); // filePath -> { size, mtime }
   }
 
@@ -17,7 +23,7 @@ class CtmAdapter extends AdapterBase {
 
     for (const { filePath, projectPath, projectEntry } of sessionFiles) {
       let stat;
-      try { stat = fs.statSync(filePath); } catch { continue; }
+      try { stat = fs.statSync(claudeDesktopSessions.sourcePathForStat(filePath)); } catch { continue; }
 
       // Skip files that are too large to avoid OOM
       if (stat.size > MAX_FILE_SIZE) continue;
@@ -81,8 +87,9 @@ class CtmAdapter extends AdapterBase {
     const sourceId = rawData.uuid || rawData._filePath || `ctm-${Date.now()}`;
     const timestamp = rawData.timestamp || new Date().toISOString();
 
+    const source = rawData._source === claudeDesktopSessions.DESKTOP_AGENT ? claudeDesktopSessions.DESKTOP_AGENT : 'ctm';
     const result = {
-      source: 'ctm',
+      source,
       source_id: sourceId,
       memory_type: memoryType,
       direction,
@@ -110,31 +117,45 @@ class CtmAdapter extends AdapterBase {
 
   _getAllSessionFiles() {
     const results = [];
-    if (!fs.existsSync(this.projectsDir)) return results;
 
-    let entries;
-    try { entries = fs.readdirSync(this.projectsDir); } catch { return results; }
+    if (fs.existsSync(this.projectsDir)) {
+      let entries;
+      try { entries = fs.readdirSync(this.projectsDir); } catch { entries = []; }
 
-    for (const projectEntry of entries) {
-      const projectDir = path.join(this.projectsDir, projectEntry);
-      let stat;
-      try { stat = fs.statSync(projectDir); } catch { continue; }
-      if (!stat.isDirectory()) continue;
+      for (const projectEntry of entries) {
+        const projectDir = path.join(this.projectsDir, projectEntry);
+        let stat;
+        try { stat = fs.statSync(projectDir); } catch { continue; }
+        if (!stat.isDirectory()) continue;
+
+        const projectPath = this._decodeProjectEntry(projectEntry);
+        let files;
+        try { files = fs.readdirSync(projectDir); } catch { continue; }
 
-      const projectPath = this._decodeProjectEntry(projectEntry);
-      let files;
-      try { files = fs.readdirSync(projectDir); } catch { continue; }
+        for (const file of files) {
+          if (!file.endsWith('.jsonl') && !file.endsWith('.jsonl.bak')) continue;
+          const filePath = path.join(projectDir, file);
+          results.push({ filePath, projectPath, projectEntry });
+        }
+      }
+    }
 
-      for (const file of files) {
-        if (!file.endsWith('.jsonl') && !file.endsWith('.jsonl.bak')) continue;
-        const filePath = path.join(projectDir, file);
-        results.push({ filePath, projectPath, projectEntry });
+    if (this.includeClaudeDesktop) {
+      for (const entry of claudeDesktopSessions.listSessionFileEntries({
+        appSupportDirs: this.desktopAppSupportDirs || undefined,
+      })) {
+        results.push(entry);
       }
     }
     return results;
   }
 
   _parseSessionFile(filePath) {
+    const desktopSession = claudeDesktopSessions.getSessionFromVirtualPath(filePath, {
+      appSupportDirs: this.desktopAppSupportDirs || undefined,
+    });
+    if (desktopSession) return claudeDesktopSessions.toClaudeCodeEntries(desktopSession);
+
     let data;
     try { data = fs.readFileSync(filePath, 'utf8'); } catch { return []; }
 

package/template/wall-e/agent-runners/contract.js

@@ -14,8 +14,15 @@ function normalizeAgentMode(mode) {
 
 function normalizeAgentRunResult(result = {}, fallback = {}) {
   const sessionId = result.sessionId || fallback.sessionId || crypto.randomUUID();
+  const runId = result.runId || fallback.runId || createAgentRunId();
   const exitCode = Number.isInteger(result.exitCode) ? result.exitCode : (result.success ? 0 : -1);
+  const errors = Array.isArray(result.errors)
+    ? result.errors
+    : (result.error ? [{ message: String(result.error) }] : []);
   return {
+    id: runId,
+    runId,
+    parentRunId: result.parentRunId || fallback.parentRunId || null,
     runnerId: result.runnerId || fallback.runnerId || 'unknown',
     providerType: result.providerType || fallback.providerType || 'unknown',
     kind: 'cli-agent',
@@ -25,6 +32,14 @@ function normalizeAgentRunResult(result = {}, fallback = {}) {
     stderr: result.stderr || '',
     sessionId,
     resumeHandle: result.resumeHandle || sessionId,
+    session: {
+      id: sessionId,
+      resumeToken: result.resumeHandle || sessionId,
+      persistent: Boolean(result.persistent ?? fallback.persistent),
+      cleanupPolicy: result.cleanupPolicy || fallback.cleanupPolicy || 'delete-on-complete',
+      threadId: result.threadId || fallback.threadId || null,
+      status: result.sessionStatus || fallback.sessionStatus || null,
+    },
     exitCode,
     timedOut: Boolean(result.timedOut),
     signal: result.signal || null,
@@ -34,7 +49,9 @@ function normalizeAgentRunResult(result = {}, fallback = {}) {
     diff: result.diff || '',
     usage: result.usage || null,
     costEstimate: result.costEstimate || null,
+    trace: result.trace || fallback.trace || null,
     artifacts: result.artifacts || {},
+    errors,
   };
 }
 

package/template/wall-e/agent-runners/index.js

@@ -26,6 +26,27 @@ function listAgentRunners() {
   }));
 }
 
+function listAgentHarnesses() {
+  return [...RUNNERS.values()].map(runner => ({
+    id: runner.id,
+    runnerId: runner.id,
+    providerType: runner.providerType,
+    kind: runner.kind || 'cli-agent',
+    priority: Number.isFinite(Number(runner.priority)) ? Number(runner.priority) : 0,
+    capabilities: {
+      modes: runner.capabilities?.modes || ['plan', 'build', 'review', 'analysis'],
+      persistentSessions: Boolean(runner.capabilities?.resume),
+      streaming: Boolean(runner.capabilities?.streamJson),
+      codeEditing: true,
+      reviewOnly: false,
+      sandboxModes: runner.capabilities?.sandboxModes || [],
+      supportsImages: Boolean(runner.capabilities?.images),
+      supportsPatch: runner.capabilities?.patch !== false,
+      ...(runner.capabilities || {}),
+    },
+  }));
+}
+
 async function runAgentTask(runnerId, options = {}) {
   const id = runnerId || 'claude-code';
   const runner = getAgentRunner(id);
@@ -57,6 +78,7 @@ module.exports = {
   registerAgentRunner,
   getAgentRunner,
   listAgentRunners,
+  listAgentHarnesses,
   runAgentTask,
   runControlledMultiAgent,
 };

package/template/wall-e/agent-runtime/harness.js

@@ -0,0 +1,212 @@
+'use strict';
+
+const { normalizeAgentMode } = require('../agent-runners/contract');
+
+function normalizeHarness(harness = {}) {
+  const id = harness.id || harness.runnerId;
+  if (!id) throw new Error('Harness id is required');
+  const providerType = harness.providerType || harness.provider || 'unknown';
+  const capabilities = {
+    modes: ['build'],
+    persistentSessions: false,
+    streaming: false,
+    codeEditing: true,
+    reviewOnly: false,
+    sandboxModes: [],
+    supportsImages: false,
+    supportsPatch: true,
+    ...(harness.capabilities || {}),
+  };
+  return {
+    ...harness,
+    id,
+    runnerId: harness.runnerId || id,
+    providerType,
+    kind: harness.kind || 'cli-agent',
+    priority: Number.isFinite(Number(harness.priority)) ? Number(harness.priority) : 0,
+    capabilities,
+  };
+}
+
+function createHarnessFromRunner(runner = {}, extra = {}) {
+  const normalized = normalizeHarness({
+    id: runner.id,
+    runnerId: runner.id,
+    providerType: runner.providerType,
+    kind: runner.kind || 'cli-agent',
+    capabilities: {
+      modes: runner.capabilities?.modes || ['plan', 'build', 'review', 'analysis'],
+      persistentSessions: Boolean(runner.capabilities?.resume),
+      streaming: Boolean(runner.capabilities?.streamJson),
+      codeEditing: true,
+      reviewOnly: false,
+      sandboxModes: runner.capabilities?.sandboxModes || [],
+      supportsImages: Boolean(runner.capabilities?.images),
+      supportsPatch: runner.capabilities?.patch !== false,
+      ...(runner.capabilities || {}),
+    },
+    run: async (request) => runner.runTask(request),
+    ...extra,
+  });
+  return normalized;
+}
+
+class AgentHarnessRegistry {
+  constructor() {
+    this.harnesses = new Map();
+  }
+
+  registerHarness(harness) {
+    const normalized = normalizeHarness(harness);
+    if (typeof normalized.run !== 'function' && !normalized.runnerId) {
+      throw new Error(`Harness ${normalized.id} needs a run function or runnerId`);
+    }
+    this.harnesses.set(normalized.id, normalized);
+    return normalized;
+  }
+
+  getHarness(id) {
+    return this.harnesses.get(id) || null;
+  }
+
+  listHarnesses() {
+    return [...this.harnesses.values()].map((harness) => ({
+      id: harness.id,
+      runnerId: harness.runnerId,
+      providerType: harness.providerType,
+      kind: harness.kind,
+      priority: harness.priority,
+      capabilities: harness.capabilities,
+    }));
+  }
+
+  candidates() {
+    return [...this.harnesses.values()];
+  }
+}
+
+function createDefaultHarnessRegistry({ runners = null } = {}) {
+  const registry = new AgentHarnessRegistry();
+  const source = runners || lazyListRunners();
+  for (const runner of source) {
+    registry.registerHarness(createHarnessFromRunner(runner));
+  }
+  return registry;
+}
+
+function harnessSupportsRequest(harness, request = {}) {
+  const normalized = normalizeHarness(harness);
+  const mode = normalizeAgentMode(request.mode || 'build');
+  const modes = normalized.capabilities.modes || [];
+  if (modes.length > 0 && !modes.includes(mode)) return false;
+  if (normalized.capabilities.reviewOnly && mode !== 'review') return false;
+  if (request.providerType && normalized.providerType !== request.providerType) return false;
+  if (request.provider && normalized.providerType !== request.provider) return false;
+  if (request.runnerId && normalized.runnerId !== request.runnerId && normalized.id !== request.runnerId) return false;
+  if (request.harnessId && normalized.id !== request.harnessId) return false;
+  if (request.sandbox && Array.isArray(normalized.capabilities.sandboxModes) && normalized.capabilities.sandboxModes.length > 0) {
+    if (!normalized.capabilities.sandboxModes.includes(request.sandbox)) return false;
+  }
+  return true;
+}
+
+function scoreHarness(harness, request = {}, opts = {}) {
+  const normalized = normalizeHarness(harness);
+  let score = 0.5 + normalized.priority / 100;
+  const mode = normalizeAgentMode(request.mode || 'build');
+  if (request.harnessId === normalized.id) score += 0.35;
+  if (request.runnerId && (request.runnerId === normalized.runnerId || request.runnerId === normalized.id)) score += 0.20;
+  if (request.providerType === normalized.providerType || request.provider === normalized.providerType) score += 0.15;
+  if (request.model && normalized.model === request.model) score += 0.05;
+  if (mode === 'review' && normalized.providerType && request.builderProviderType && normalized.providerType !== request.builderProviderType) score += 0.08;
+  if (normalized.capabilities.persistentSessions) score += request.persistent ? 0.08 : 0.02;
+  if (normalized.capabilities.streaming) score += 0.02;
+
+  const availability = opts.providerAvailability;
+  if (availability?.isProviderUsable) {
+    if (!availability.isProviderUsable(normalized.providerType)) score -= 0.40;
+  } else if (availability?.getProviderState) {
+    const state = availability.getProviderState(normalized.providerType);
+    if (state?.status === 'unhealthy') score -= 0.40;
+  }
+
+  const quality = Number(opts.qualityScore ?? normalized.qualityScore);
+  if (Number.isFinite(quality)) score += (quality - 0.5) * 0.25;
+
+  return Math.max(0, Math.min(1, score));
+}
+
+function selectAgentHarness(request = {}, candidates = [], opts = {}) {
+  const list = candidates.length > 0
+    ? candidates.map(normalizeHarness)
+    : (opts.registry ? opts.registry.candidates() : []);
+  const supported = list.filter(harness => harnessSupportsRequest(harness, request));
+  const scored = supported.map((harness, index) => ({
+    harness,
+    score: scoreHarness(harness, request, opts),
+    index,
+  }));
+  scored.sort((a, b) => {
+    if (b.score !== a.score) return b.score - a.score;
+    if (b.harness.priority !== a.harness.priority) return b.harness.priority - a.harness.priority;
+    return a.index - b.index;
+  });
+  const winner = scored[0] || null;
+  return {
+    selected: winner?.harness || null,
+    candidates: scored.map(entry => ({
+      ...entry.harness,
+      score: entry.score,
+    })),
+    reason: winner ? 'selected-highest-scoring-supported-harness' : 'no-supported-harness',
+  };
+}
+
+async function runSelectedHarness(request = {}, opts = {}) {
+  const registry = opts.registry || createDefaultHarnessRegistry(opts);
+  const selection = selectAgentHarness(request, [], { ...opts, registry });
+  if (!selection.selected) {
+    return {
+      success: false,
+      error: selection.reason,
+      selection,
+    };
+  }
+  const harness = selection.selected;
+  if (typeof harness.run === 'function') {
+    const result = await harness.run({
+      ...request,
+      runnerId: harness.runnerId,
+      providerType: harness.providerType,
+    });
+    return { ...result, harnessId: harness.id, selection };
+  }
+  const runner = opts.runTask || lazyRunAgentTask();
+  const result = await runner(harness.runnerId, {
+    ...request,
+    providerType: harness.providerType,
+  });
+  return { ...result, harnessId: harness.id, selection };
+}
+
+function lazyListRunners() {
+  const runners = require('../agent-runners');
+  return ['claude-code', 'codex', 'gemini']
+    .map(id => runners.getAgentRunner(id))
+    .filter(Boolean);
+}
+
+function lazyRunAgentTask() {
+  return require('../agent-runners').runAgentTask;
+}
+
+module.exports = {
+  AgentHarnessRegistry,
+  createHarnessFromRunner,
+  createDefaultHarnessRegistry,
+  harnessSupportsRequest,
+  normalizeHarness,
+  runSelectedHarness,
+  scoreHarness,
+  selectAgentHarness,
+};

package/template/wall-e/agent-runtime/index.js

@@ -0,0 +1,8 @@
+'use strict';
+
+module.exports = {
+  ...require('./harness'),
+  ...require('./registry'),
+  ...require('./session-store'),
+  ...require('./spawn'),
+};

package/template/wall-e/agent-runtime/registry.js

@@ -0,0 +1,67 @@
+'use strict';
+
+class AgentRuntimeRegistry {
+  constructor() {
+    this.runtimes = new Map();
+  }
+
+  registerRuntime(runtime) {
+    if (!runtime || !runtime.id || typeof runtime.run !== 'function') {
+      throw new Error('Invalid agent runtime');
+    }
+    this.runtimes.set(runtime.id, runtime);
+    return runtime;
+  }
+
+  getRuntime(id = 'cli-agent') {
+    return this.runtimes.get(id) || null;
+  }
+
+  listRuntimes() {
+    return [...this.runtimes.values()].map((runtime) => ({
+      id: runtime.id,
+      kind: runtime.kind || runtime.id,
+      capabilities: runtime.capabilities || {},
+    }));
+  }
+
+  clear() {
+    this.runtimes.clear();
+  }
+}
+
+function createDefaultRuntimeRegistry({ runTask } = {}) {
+  const registry = new AgentRuntimeRegistry();
+  registry.registerRuntime({
+    id: 'cli-agent',
+    kind: 'cli-agent',
+    capabilities: {
+      oneshot: true,
+      persistentSessions: false,
+      streaming: false,
+    },
+    run: async (request) => {
+      const runner = runTask || lazyRunAgentTask();
+      return runner(request.runnerId, {
+        prompt: request.task || request.prompt || '',
+        cwd: request.cwd,
+        timeoutMs: request.timeoutMs,
+        model: request.model,
+        mode: request.mode,
+        sessionId: request.sessionId,
+        writeScope: request.writeScope,
+        sandbox: request.sandbox,
+      });
+    },
+  });
+  return registry;
+}
+
+function lazyRunAgentTask() {
+  return require('../agent-runners').runAgentTask;
+}
+
+module.exports = {
+  AgentRuntimeRegistry,
+  createDefaultRuntimeRegistry,
+};

package/template/wall-e/agent-runtime/session-store.js

@@ -0,0 +1,179 @@
+'use strict';
+
+const crypto = require('node:crypto');
+const fs = require('node:fs');
+const path = require('node:path');
+
+function createSessionId(prefix = 'agent-session') {
+  return `${prefix}-${crypto.randomUUID()}`;
+}
+
+function nowIso() {
+  return new Date().toISOString();
+}
+
+function clone(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+
+class AgentSessionStore {
+  constructor({ persistencePath = null, clock = nowIso } = {}) {
+    this.persistencePath = persistencePath;
+    this.clock = clock;
+    this.sessions = new Map();
+    this._load();
+  }
+
+  createSession(data = {}) {
+    const timestamp = this.clock();
+    const id = data.id || data.sessionId || createSessionId();
+    const session = {
+      id,
+      parentRunId: data.parentRunId || null,
+      runtime: data.runtime || data.kind || 'cli-agent',
+      runnerId: data.runnerId || data.runner || 'unknown',
+      providerType: data.providerType || data.provider || 'unknown',
+      model: data.model || null,
+      mode: data.mode || 'build',
+      cwd: data.cwd || process.cwd(),
+      sandbox: data.sandbox || null,
+      task: data.task || data.prompt || '',
+      status: data.status || 'created',
+      persistent: Boolean(data.persistent),
+      cleanupPolicy: data.cleanupPolicy || (data.persistent ? 'manual' : 'delete-on-complete'),
+      threadId: data.threadId || null,
+      resumeHandle: data.resumeHandle || data.resumeToken || id,
+      createdAt: data.createdAt || timestamp,
+      updatedAt: data.updatedAt || timestamp,
+      startedAt: data.startedAt || null,
+      completedAt: data.completedAt || null,
+      lastError: data.lastError || null,
+      metadata: { ...(data.metadata || {}) },
+    };
+    this.sessions.set(id, session);
+    this._persist();
+    return clone(session);
+  }
+
+  getSession(id) {
+    if (!id) return null;
+    const session = this.sessions.get(id);
+    return session ? clone(session) : null;
+  }
+
+  listSessions(filter = {}) {
+    return [...this.sessions.values()]
+      .filter((session) => {
+        if (filter.parentRunId && session.parentRunId !== filter.parentRunId) return false;
+        if (filter.runnerId && session.runnerId !== filter.runnerId) return false;
+        if (filter.status && session.status !== filter.status) return false;
+        return true;
+      })
+      .map(clone);
+  }
+
+  updateSession(id, patch = {}) {
+    const session = this.sessions.get(id);
+    if (!session) return null;
+    const next = {
+      ...session,
+      ...patch,
+      metadata: {
+        ...(session.metadata || {}),
+        ...(patch.metadata || {}),
+      },
+      updatedAt: this.clock(),
+    };
+    this.sessions.set(id, next);
+    this._persist();
+    return clone(next);
+  }
+
+  markRunning(id, patch = {}) {
+    return this.updateSession(id, {
+      ...patch,
+      status: 'running',
+      startedAt: patch.startedAt || this.clock(),
+      lastError: null,
+    });
+  }
+
+  markCompleted(id, result = {}) {
+    return this.updateSession(id, {
+      status: result.success === false ? 'failed' : 'completed',
+      completedAt: this.clock(),
+      resumeHandle: result.resumeHandle || result.sessionId || id,
+      lastError: result.success === false
+        ? String(result.error || result.stderr || 'Agent run failed')
+        : null,
+      metadata: {
+        exitCode: result.exitCode,
+        changedFiles: Array.isArray(result.changedFiles) ? result.changedFiles : [],
+        timedOut: Boolean(result.timedOut),
+      },
+    });
+  }
+
+  markFailed(id, error) {
+    return this.updateSession(id, {
+      status: 'failed',
+      completedAt: this.clock(),
+      lastError: error?.message || String(error || 'Agent run failed'),
+    });
+  }
+
+  deleteSession(id) {
+    const existed = this.sessions.delete(id);
+    if (existed) this._persist();
+    return existed;
+  }
+
+  cleanupCompleted({ includePersistent = false } = {}) {
+    let count = 0;
+    for (const session of this.sessions.values()) {
+      const terminal = session.status === 'completed' || session.status === 'failed' || session.status === 'canceled';
+      const cleanup = session.cleanupPolicy === 'delete-on-complete' || (includePersistent && session.persistent);
+      if (terminal && cleanup) {
+        this.sessions.delete(session.id);
+        count += 1;
+      }
+    }
+    if (count > 0) this._persist();
+    return count;
+  }
+
+  clear() {
+    this.sessions.clear();
+    this._persist();
+  }
+
+  _load() {
+    if (!this.persistencePath) return;
+    try {
+      const raw = fs.readFileSync(this.persistencePath, 'utf8');
+      const parsed = JSON.parse(raw);
+      for (const session of parsed.sessions || []) {
+        if (session?.id) this.sessions.set(session.id, session);
+      }
+    } catch (err) {
+      if (err.code !== 'ENOENT') throw err;
+    }
+  }
+
+  _persist() {
+    if (!this.persistencePath) return;
+    const dir = path.dirname(this.persistencePath);
+    fs.mkdirSync(dir, { recursive: true });
+    const tmp = `${this.persistencePath}.tmp`;
+    fs.writeFileSync(tmp, JSON.stringify({ sessions: [...this.sessions.values()] }, null, 2));
+    fs.renameSync(tmp, this.persistencePath);
+  }
+}
+
+const defaultSessionStore = new AgentSessionStore();
+
+module.exports = {
+  AgentSessionStore,
+  createSessionId,
+  defaultSessionStore,
+};