ticlawk 0.1.12-dev.0

package/src/runtimes/claude-code/session.mjs

@@ -0,0 +1,388 @@
+/**
+ * Claude Code local session helpers.
+ *
+ * Pure functions and constants for working with `claude` CLI sessions:
+ * project directory encoding, transcript path resolution, spawning
+ * `claude -p` for prompt delivery and session creation.
+ */
+
+import { spawn } from 'node:child_process';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { debugLog, debugError } from '../../core/logger.mjs';
+import { buildRuntimeEnv } from '../../core/runtime-env.mjs';
+import { getRuntimeExecutableConfig } from '../../core/config.mjs';
+import { getExecutableVersion, isExecutablePath, resolveExecutable } from '../../core/executables.mjs';
+
+export const CC_PROJECTS_DIR = process.env.CC_PROJECTS_DIR || `${homedir()}/.claude/projects`;
+// Only watch sessions active in last 24h.
+export const CC_MAX_AGE_MS = 24 * 60 * 60 * 1000;
+export const DEFAULT_CC_EXEC_TIMEOUT_MS = 7200 * 1000;
+export const DEFAULT_CC_COMMAND = 'claude';
+
+export function resolveClaudePath(preferredPath = null) {
+  return resolveExecutable({
+    command: DEFAULT_CC_COMMAND,
+    preferredPath,
+    configuredPath: getRuntimeExecutableConfig('claude_code'),
+    envKey: 'CLAUDE_CODE_BIN',
+  });
+}
+
+export function requireClaudePath(preferredPath = null) {
+  const requested = String(preferredPath || '').trim();
+  if (requested && requested.includes('/') && !isExecutablePath(requested)) {
+    throw new Error(`Claude Code binary is no longer available at: ${requested}. Reconnect this Claude Code agent or set CLAUDE_CODE_BIN / \`ticlawk config set runtimes.claude_code.path <path>\`.`);
+  }
+  const claudePath = resolveClaudePath(preferredPath);
+  if (claudePath) return claudePath;
+  throw new Error('Claude Code CLI not found. Install Claude Code, ensure it is on PATH, or set CLAUDE_CODE_BIN / `ticlawk config set runtimes.claude_code.path <path>`.');
+}
+
+export function getClaudeCodeRuntimeHealth(preferredPath = null) {
+  const claudePath = resolveClaudePath(preferredPath);
+  return {
+    available: Boolean(claudePath),
+    path: claudePath,
+    version: getExecutableVersion(claudePath),
+  };
+}
+
+export function prettyProjectName(encoded) {
+  // "-home-wei-Projects-myapp" → "myapp"
+  const parts = encoded.replace(/^-/, '').split('-');
+  // Find the last meaningful segment (skip home, user, Projects)
+  const skip = new Set(['home', 'wei', 'Projects']);
+  const meaningful = parts.filter(p => !skip.has(p));
+  return meaningful.join('-') || encoded;
+}
+
+export function encodeClaudeProjectDir(projectDir) {
+  return `-${String(projectDir || '').replace(/^\/+/, '').replace(/\//g, '-')}`;
+}
+
+export function getClaudeTranscriptPath(projectDir, sessionId) {
+  return join(CC_PROJECTS_DIR, encodeClaudeProjectDir(projectDir), `${sessionId}.jsonl`);
+}
+
+// Try to recover a human-readable error string from `claude -p
+// --output-format json` stdout when the child exits non-zero. The
+// stream prints jsonl events; on failure the last `result` event
+// (or any event with `is_error: true`) usually carries the message.
+function extractCCError(stdout) {
+  if (!stdout) return null;
+  const lines = stdout.split('\n').map(l => l.trim()).filter(Boolean);
+  for (let i = lines.length - 1; i >= 0; i--) {
+    let parsed;
+    try { parsed = JSON.parse(lines[i]); } catch { continue; }
+    if (parsed?.is_error && typeof parsed.result === 'string') return parsed.result;
+    if (typeof parsed?.error === 'string') return parsed.error;
+    if (typeof parsed?.error?.message === 'string') return parsed.error.message;
+    if (parsed?.type === 'result' && typeof parsed.result === 'string') return parsed.result;
+  }
+  // Fallback: raw last line
+  return lines[lines.length - 1] || null;
+}
+
+function extractCCResultPayload(stdout) {
+  if (!stdout) return null;
+  const lines = stdout.split('\n').map(l => l.trim()).filter(Boolean);
+  for (let i = lines.length - 1; i >= 0; i--) {
+    try {
+      const parsed = JSON.parse(lines[i]);
+      if (parsed?.type === 'result') return parsed;
+      if (typeof parsed?.result === 'string') return parsed;
+    } catch {}
+  }
+  return null;
+}
+
+function extractCCAssistantText(payload) {
+  const content = payload?.message?.content;
+  if (!Array.isArray(content)) return '';
+  return content
+    .filter((block) => block?.type === 'text' && typeof block.text === 'string')
+    .map((block) => block.text)
+    .join('');
+}
+
+export function runCCPrompt({ sessionId, projectDir, message, claudePath = null, timeoutMs = Number(process.env.CC_EXEC_TIMEOUT_MS || DEFAULT_CC_EXEC_TIMEOUT_MS) }) {
+  const args = sessionId
+    ? ['-p', message, '--resume', sessionId, '--dangerously-skip-permissions', '--output-format', 'json']
+    : ['-p', message, '--dangerously-skip-permissions', '--output-format', 'json'];
+
+  return new Promise((resolve, reject) => {
+    const startedAt = Date.now();
+    const claudeCommand = requireClaudePath(claudePath);
+    const child = spawn(claudeCommand, args, { cwd: projectDir, env: buildRuntimeEnv(), stdio: ['ignore', 'pipe', 'ignore'] });
+    let stdout = '';
+    let settled = false;
+
+    const settle = (fn, value) => {
+      if (settled) return;
+      settled = true;
+      if (timeout) clearTimeout(timeout);
+      fn(value);
+    };
+
+    child.stdout.on('data', (chunk) => { stdout += chunk; });
+
+    let timeout = null;
+    if (timeoutMs > 0) {
+      timeout = setTimeout(() => { child.kill('SIGTERM'); }, timeoutMs);
+      timeout.unref();
+    }
+
+    child.on('error', (err) => {
+      const wrapped = new Error(err.message || 'claude spawn failed');
+      wrapped.info = {
+        ok: false,
+        code: null,
+        signal: null,
+        durationMs: Date.now() - startedAt,
+        kind: 'spawn-failed',
+        error: err.message,
+      };
+      settle(reject, wrapped);
+    });
+
+    child.on('exit', (code, signal) => {
+      const durationMs = Date.now() - startedAt;
+      if (signal) {
+        const wrapped = new Error(extractCCError(stdout) || `claude killed by ${signal}`);
+        wrapped.info = {
+          ok: false,
+          code: null,
+          signal,
+          durationMs,
+          kind: 'killed',
+          errorMessage: extractCCError(stdout),
+        };
+        settle(reject, wrapped);
+        return;
+      }
+      if (code !== 0) {
+        const wrapped = new Error(extractCCError(stdout) || `claude exited with code ${code}`);
+        wrapped.info = {
+          ok: false,
+          code,
+          signal: null,
+          durationMs,
+          kind: 'exit-error',
+          errorMessage: extractCCError(stdout),
+        };
+        settle(reject, wrapped);
+        return;
+      }
+
+      const payload = extractCCResultPayload(stdout);
+      if (!payload || typeof payload.result !== 'string') {
+        const wrapped = new Error('claude result missing from stdout');
+        wrapped.info = {
+          ok: false,
+          code: 0,
+          signal: null,
+          durationMs,
+          kind: 'invalid-output',
+          errorMessage: wrapped.message,
+        };
+        settle(reject, wrapped);
+        return;
+      }
+
+      settle(resolve, {
+        sessionId: typeof payload.session_id === 'string' ? payload.session_id : sessionId || null,
+        text: payload.result,
+        durationMs,
+        stopReason: payload.stop_reason || null,
+        raw: payload,
+      });
+    });
+  });
+}
+
+export function streamCCPrompt({
+  sessionId,
+  projectDir,
+  message,
+  claudePath = null,
+  timeoutMs = Number(process.env.CC_EXEC_TIMEOUT_MS || DEFAULT_CC_EXEC_TIMEOUT_MS),
+  onEvent,
+}) {
+  const args = sessionId
+    ? ['-p', message, '--resume', sessionId, '--verbose', '--output-format', 'stream-json', '--include-partial-messages', '--dangerously-skip-permissions']
+    : ['-p', message, '--verbose', '--output-format', 'stream-json', '--include-partial-messages', '--dangerously-skip-permissions'];
+
+  return new Promise((resolve, reject) => {
+    const startedAt = Date.now();
+    const claudeCommand = requireClaudePath(claudePath);
+    const child = spawn(claudeCommand, args, { cwd: projectDir, env: buildRuntimeEnv(), stdio: ['ignore', 'pipe', 'ignore'] });
+    let stdout = '';
+    let buffer = '';
+    let settled = false;
+    let seenTurnStart = false;
+    let activeSessionId = sessionId || null;
+    let finalText = '';
+    let eventChain = Promise.resolve();
+
+    const emit = (event) => {
+      if (typeof onEvent !== 'function') return;
+      eventChain = eventChain
+        .then(() => onEvent(event))
+        .catch(() => {});
+      return eventChain;
+    };
+
+    const settle = (fn, value) => {
+      if (settled) return;
+      settled = true;
+      if (timeout) clearTimeout(timeout);
+      eventChain
+        .catch(() => {})
+        .finally(() => fn(value));
+    };
+
+    const parseLine = (line) => {
+      let parsed;
+      try { parsed = JSON.parse(line); } catch { return; }
+
+      if (typeof parsed?.session_id === 'string') {
+        activeSessionId = parsed.session_id;
+      }
+
+      if (!seenTurnStart && activeSessionId && (parsed?.type === 'system' || parsed?.type === 'stream_event')) {
+        seenTurnStart = true;
+        emit({ type: 'turn.started', sessionId: activeSessionId });
+      }
+
+      if (parsed?.type === 'stream_event' && parsed.event?.type === 'content_block_delta') {
+        const deltaText = parsed.event?.delta?.text;
+        if (typeof deltaText === 'string' && deltaText) {
+          finalText += deltaText;
+          emit({ type: 'message.delta', sessionId: activeSessionId, text: deltaText });
+        }
+        return;
+      }
+
+      if (parsed?.type === 'assistant') {
+        const assistantText = extractCCAssistantText(parsed);
+        if (assistantText) finalText = assistantText;
+        return;
+      }
+
+      if (parsed?.type === 'result' && typeof parsed.result === 'string') {
+        finalText = parsed.result;
+      }
+    };
+
+    child.stdout.on('data', (chunk) => {
+      const text = chunk.toString('utf8');
+      stdout += text;
+      buffer += text;
+      const lines = buffer.split('\n');
+      buffer = lines.pop() || '';
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+        parseLine(trimmed);
+      }
+    });
+
+    let timeout = null;
+    if (timeoutMs > 0) {
+      timeout = setTimeout(() => { child.kill('SIGTERM'); }, timeoutMs);
+      timeout.unref();
+    }
+
+    child.on('error', (err) => {
+      const wrapped = new Error(err.message || 'claude spawn failed');
+      wrapped.info = {
+        ok: false,
+        code: null,
+        signal: null,
+        durationMs: Date.now() - startedAt,
+        kind: 'spawn-failed',
+        error: err.message,
+      };
+      settle(reject, wrapped);
+    });
+
+    child.on('exit', (code, signal) => {
+      const durationMs = Date.now() - startedAt;
+      const trailing = buffer.trim();
+      if (trailing) parseLine(trailing);
+      if (signal) {
+        const wrapped = new Error(extractCCError(stdout) || `claude killed by ${signal}`);
+        wrapped.info = {
+          ok: false,
+          code: null,
+          signal,
+          durationMs,
+          kind: 'killed',
+          errorMessage: extractCCError(stdout),
+        };
+        settle(reject, wrapped);
+        return;
+      }
+      if (code !== 0) {
+        const wrapped = new Error(extractCCError(stdout) || `claude exited with code ${code}`);
+        wrapped.info = {
+          ok: false,
+          code,
+          signal: null,
+          durationMs,
+          kind: 'exit-error',
+          errorMessage: extractCCError(stdout),
+        };
+        settle(reject, wrapped);
+        return;
+      }
+      const payload = extractCCResultPayload(stdout);
+      if (payload?.result && typeof payload.result === 'string') {
+        finalText = payload.result;
+      }
+      if (!finalText) {
+        const wrapped = new Error('claude result missing from stdout');
+        wrapped.info = {
+          ok: false,
+          code: 0,
+          signal: null,
+          durationMs,
+          kind: 'invalid-output',
+          errorMessage: wrapped.message,
+        };
+        settle(reject, wrapped);
+        return;
+      }
+      settle(resolve, {
+        sessionId: activeSessionId || (typeof payload?.session_id === 'string' ? payload.session_id : sessionId || null),
+        text: finalText,
+        durationMs,
+        stopReason: payload?.stop_reason || null,
+        raw: payload || null,
+      });
+    });
+  });
+}
+
+export async function createCCSession({ projectDir, message, claudePath = null, timeoutMs = Number(process.env.CC_EXEC_TIMEOUT_MS || DEFAULT_CC_EXEC_TIMEOUT_MS) }) {
+  const result = await runCCPrompt({ projectDir, message, claudePath, timeoutMs });
+  if (!result?.sessionId) {
+    const wrapped = new Error('claude session_id missing from output');
+    wrapped.info = {
+      ok: false,
+      code: 0,
+      signal: null,
+      durationMs: result?.durationMs || 0,
+      kind: 'invalid-output',
+      errorMessage: wrapped.message,
+    };
+    throw wrapped;
+  }
+  return {
+    sessionId: String(result.sessionId),
+    resultText: typeof result.text === 'string' ? result.text : '',
+    durationMs: result.durationMs || 0,
+    raw: result.raw || null,
+  };
+}

package/src/runtimes/claude-code/transcripts.mjs

@@ -0,0 +1,206 @@
+/**
+ * Claude Code transcript helpers.
+ *
+ * Discovers Claude Code sessions and exposes transcript utilities. Runtime
+ * code should import this module directly; the root cc-watcher.mjs file is
+ * kept as a compatibility re-export for older deep imports.
+ */
+
+import { readFileSync, statSync, watch } from 'node:fs';
+import { readdir } from 'node:fs/promises';
+import { join, basename } from 'node:path';
+
+/**
+ * Scan a .claude/projects/ directory for session .jsonl files.
+ * Returns an array of { sessionId, project, path, projectDir }.
+ */
+export async function discoverSessions(claudeProjectsDir) {
+  const sessions = [];
+
+  let projectDirs;
+  try {
+    projectDirs = await readdir(claudeProjectsDir);
+  } catch {
+    return sessions;
+  }
+
+  for (const projName of projectDirs) {
+    const projPath = join(claudeProjectsDir, projName);
+
+    let files;
+    try {
+      files = await readdir(projPath);
+    } catch {
+      continue;
+    }
+
+    for (const file of files) {
+      if (!file.endsWith('.jsonl')) continue;
+      if (file.includes('subagent')) continue;
+
+      const filePath = join(projPath, file);
+      try {
+        statSync(filePath);
+      } catch {
+        continue;
+      }
+
+      const sessionId = basename(file, '.jsonl');
+
+      let projectDir = null;
+      try {
+        const content = readFileSync(filePath, 'utf8');
+        for (const line of content.split('\n')) {
+          if (!line.trim()) continue;
+          const entry = JSON.parse(line);
+          if (entry.cwd) {
+            projectDir = entry.cwd;
+            break;
+          }
+        }
+      } catch { /* ignore */ }
+
+      if (!projectDir) {
+        projectDir = '/' + projName.replace(/^-/, '').replace(/-/g, '/');
+      }
+
+      sessions.push({
+        sessionId,
+        project: projName,
+        path: filePath,
+        projectDir,
+      });
+    }
+  }
+
+  return sessions;
+}
+
+/**
+ * Watch a transcript .jsonl file for new assistant messages.
+ * Calls onMessage(msg) when a new assistant message is detected.
+ * msg = { type: 'assistant', text: string, raw: object }
+ *
+ * Returns a cleanup function to stop watching.
+ */
+export function watchTranscript(transcriptPath, onMessage) {
+  let lastSize = 0;
+
+  try {
+    lastSize = statSync(transcriptPath).size;
+  } catch {
+    // File might not exist yet.
+  }
+
+  const checkForNew = () => {
+    let currentSize;
+    try {
+      currentSize = statSync(transcriptPath).size;
+    } catch {
+      return;
+    }
+
+    if (currentSize <= lastSize) return;
+
+    const buf = readFileSync(transcriptPath);
+    const newContent = buf.subarray(lastSize).toString('utf8');
+    lastSize = currentSize;
+
+    const lines = newContent.split('\n').filter(l => l.trim());
+    for (const line of lines) {
+      let entry;
+      try {
+        entry = JSON.parse(line);
+      } catch {
+        continue;
+      }
+
+      if (entry.type !== 'assistant' && entry.type !== 'user') continue;
+
+      const content = entry.message?.content;
+      let text = '';
+      let toolNames = [];
+      if (typeof content === 'string') {
+        text = content;
+      } else if (Array.isArray(content)) {
+        text = content
+          .filter(c => c.type === 'text')
+          .map(c => c.text)
+          .join('\n');
+        toolNames = content
+          .filter(c => c.type === 'tool_use')
+          .map(c => c.name);
+      }
+
+      const stopReason = entry.message?.stop_reason;
+
+      if (entry.type === 'assistant' && toolNames.length > 0 && stopReason === 'tool_use') {
+        Promise.resolve(onMessage({ type: 'tool_use', text: '', toolNames, raw: entry })).catch((err) => {
+          console.error('[cc-watcher] onMessage failed:', err.message);
+        });
+        continue;
+      }
+
+      if (!text) continue;
+
+      Promise.resolve(onMessage({ type: entry.type, text, raw: entry })).catch((err) => {
+        console.error('[cc-watcher] onMessage failed:', err.message);
+      });
+    }
+  };
+
+  let watcher;
+  try {
+    watcher = watch(transcriptPath, { persistent: false }, () => {
+      checkForNew();
+    });
+  } catch {
+    // fs.watch not available; polling below still covers updates.
+  }
+
+  const interval = setInterval(checkForNew, 2000);
+
+  return () => {
+    clearInterval(interval);
+    watcher?.close();
+  };
+}
+
+function extractText(entry) {
+  const content = entry.message?.content;
+  if (typeof content === 'string') return content;
+  if (Array.isArray(content)) {
+    return content.filter(c => c.type === 'text').map(c => c.text).join('\n');
+  }
+  return '';
+}
+
+/**
+ * Read transcript and return all user/assistant messages.
+ * Each entry: { type: 'user'|'assistant', text: string, timestamp: number }
+ */
+export function readTranscript(transcriptPath) {
+  let content;
+  try {
+    content = readFileSync(transcriptPath, 'utf8');
+  } catch {
+    return [];
+  }
+
+  const messages = [];
+  for (const line of content.split('\n')) {
+    if (!line.trim()) continue;
+    let entry;
+    try { entry = JSON.parse(line); } catch { continue; }
+
+    if (entry.type !== 'user' && entry.type !== 'assistant') continue;
+
+    const text = extractText(entry);
+    if (!text) continue;
+
+    const timestamp = entry.message?.timestamp || entry.timestamp || 0;
+    messages.push({ type: entry.type, text, timestamp });
+  }
+
+  return messages;
+}