@kkelly-offical/kkcode 0.1.2

package/src/orchestration/background-manager.mjs

@@ -0,0 +1,358 @@
+import path from "node:path"
+import { spawn } from "node:child_process"
+import { openSync, closeSync } from "node:fs"
+import { readdir, unlink } from "node:fs/promises"
+import { fileURLToPath } from "node:url"
+import { readJson, writeJson } from "../storage/json-store.mjs"
+import {
+  ensureBackgroundTaskRuntimeDir,
+  backgroundTaskCheckpointPath,
+  backgroundTaskLogPath,
+  backgroundTaskRuntimeDir
+} from "../storage/paths.mjs"
+
+const WORKER_ENTRY = fileURLToPath(new URL("./background-worker.mjs", import.meta.url))
+const TERMINAL_STATES = new Set(["completed", "cancelled", "error", "interrupted"])
+
+function now() {
+  return Date.now()
+}
+
+function resolveWorkerTimeoutMs(config = {}, payload = {}) {
+  return Math.max(1000, Number(payload.workerTimeoutMs || config.background?.worker_timeout_ms || 900000))
+}
+
+function resolveMaxParallel(config = {}) {
+  return Math.max(1, Number(config.background?.max_parallel || 2))
+}
+
+function isProcessAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false
+  try {
+    process.kill(pid, 0)
+    return true
+  } catch {
+    return false
+  }
+}
+
+async function loadTask(id) {
+  return readJson(backgroundTaskCheckpointPath(id), null)
+}
+
+async function saveTask(task) {
+  await ensureBackgroundTaskRuntimeDir()
+  await writeJson(backgroundTaskCheckpointPath(task.id), task)
+  return task
+}
+
+async function patchTask(id, updater, { maxRetries = 3 } = {}) {
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    const current = await loadTask(id)
+    if (!current) return null
+    const next = {
+      ...current,
+      ...updater(current),
+      _version: (current._version || 0) + 1,
+      updatedAt: now()
+    }
+    // Optimistic lock: re-read and verify version before write
+    const check = await loadTask(id)
+    if (check && (check._version || 0) !== (current._version || 0)) {
+      if (attempt < maxRetries) continue // version changed, retry
+      // Last attempt: write anyway to avoid deadlock
+    }
+    await saveTask(next)
+    return next
+  }
+  return null
+}
+
+async function listTaskIds() {
+  await ensureBackgroundTaskRuntimeDir()
+  const entries = await readdir(backgroundTaskRuntimeDir(), { withFileTypes: true }).catch(() => [])
+  return entries
+    .filter((entry) => entry.isFile() && entry.name.endsWith(".json"))
+    .map((entry) => path.basename(entry.name, ".json"))
+}
+
+async function readAllTasks() {
+  const ids = await listTaskIds()
+  const out = []
+  for (const id of ids) {
+    const task = await loadTask(id)
+    if (task) out.push(task)
+  }
+  return out.sort((a, b) => b.updatedAt - a.updatedAt)
+}
+
+function spawnWorker(taskId) {
+  const logFile = backgroundTaskLogPath(taskId)
+  let stderrFd = null
+  try {
+    stderrFd = openSync(logFile, "a")
+  } catch {
+    // directory may not exist yet or permission issue — fall back to ignore
+  }
+  const child = spawn(process.execPath, [WORKER_ENTRY, "--task-id", taskId], {
+    detached: true,
+    windowsHide: true,
+    stdio: ["ignore", "ignore", stderrFd !== null ? stderrFd : "ignore"],
+    env: {
+      ...process.env,
+      KKCODE_BACKGROUND_TASK_ID: taskId
+    }
+  })
+  child.on("exit", (code) => {
+    if (stderrFd !== null) {
+      try { closeSync(stderrFd) } catch { /* already closed */ }
+    }
+    if (code && code !== 0) {
+      patchTask(taskId, (current) => {
+        if (current.status === "running") {
+          return {
+            status: "error",
+            error: `worker process exited with code ${code}`,
+            endedAt: now()
+          }
+        }
+        return {}
+      }).catch(() => {})
+    }
+  })
+  child.unref()
+  return child.pid
+}
+
+async function markStaleRunningTasks(config = {}) {
+  const tasks = await readAllTasks()
+  const timeoutDefault = Math.max(1000, Number(config.background?.worker_timeout_ms || 900000))
+  let interrupted = 0
+
+  for (const task of tasks) {
+    if (task.status !== "running") continue
+    const heartbeatAt = Number(task.lastHeartbeatAt || 0)
+    const timeoutMs = resolveWorkerTimeoutMs(config, task.payload || {})
+    const staleByHeartbeat = heartbeatAt > 0 && now() - heartbeatAt > timeoutMs + 5000
+    const deadPid = task.workerPid ? !isProcessAlive(task.workerPid) : false
+    const staleNoHeartbeat = heartbeatAt === 0 && now() - Number(task.startedAt || task.createdAt || now()) > timeoutDefault + 5000
+
+    if (staleByHeartbeat || deadPid || staleNoHeartbeat) {
+      await patchTask(task.id, () => ({
+        status: "interrupted",
+        endedAt: now(),
+        error: deadPid
+          ? "background worker exited unexpectedly"
+          : staleByHeartbeat
+            ? "background worker heartbeat timeout"
+            : "background worker no heartbeat",
+        workerPid: null
+      }))
+      interrupted += 1
+    }
+  }
+
+  return interrupted
+}
+
+async function startPendingTasks(config = {}) {
+  const maxParallel = resolveMaxParallel(config)
+  const tasks = await readAllTasks()
+  const running = tasks.filter((task) => task.status === "running").length
+  let remainingSlots = Math.max(0, maxParallel - running)
+  if (remainingSlots <= 0) return 0
+
+  let started = 0
+  const pending = tasks
+    .filter((task) => task.status === "pending" && task.backgroundMode === "worker_process")
+    .sort((a, b) => a.createdAt - b.createdAt)
+
+  for (const task of pending) {
+    if (remainingSlots <= 0) break
+    let pid
+    try {
+      pid = spawnWorker(task.id)
+    } catch (err) {
+      await patchTask(task.id, () => ({
+        status: "error",
+        error: `spawn failed: ${err.message}`,
+        endedAt: now()
+      }))
+      continue
+    }
+    const timeoutMs = resolveWorkerTimeoutMs(config, task.payload || {})
+    await patchTask(task.id, (current) => ({
+      status: "running",
+      workerPid: pid,
+      lastHeartbeatAt: now(),
+      startedAt: current.startedAt || now(),
+      payload: {
+        ...(current.payload || {}),
+        workerTimeoutMs: timeoutMs
+      }
+    }))
+    remainingSlots -= 1
+    started += 1
+  }
+
+  return started
+}
+
+async function runInline(task, run) {
+  await patchTask(task.id, () => ({ status: "running", startedAt: now() }))
+  try {
+    const result = await run({
+      taskId: task.id,
+      isCancelled: async () => {
+        const latest = await loadTask(task.id)
+        return Boolean(latest?.cancelled)
+      },
+      log: async (line) => {
+        await patchTask(task.id, (current) => ({
+          logs: [...(current.logs || []), String(line)].slice(-300),
+          lastHeartbeatAt: now()
+        }))
+      }
+    })
+    const latest = await loadTask(task.id)
+    if (latest?.cancelled) {
+      await patchTask(task.id, () => ({ status: "cancelled", endedAt: now() }))
+      return
+    }
+    await patchTask(task.id, () => ({ status: "completed", result, endedAt: now() }))
+  } catch (error) {
+    const latest = await loadTask(task.id)
+    await patchTask(task.id, () => ({
+      status: latest?.cancelled ? "cancelled" : "error",
+      error: error.message,
+      endedAt: now()
+    }))
+  }
+}
+
+export const BackgroundManager = {
+  async launch({ description, payload, run = null, config = {} }) {
+    await ensureBackgroundTaskRuntimeDir()
+    const id = `bg_${Math.random().toString(36).slice(2, 14)}`
+    const timeoutMs = resolveWorkerTimeoutMs(config, payload || {})
+    const task = {
+      id,
+      description,
+      payload: {
+        ...(payload || {}),
+        workerTimeoutMs: timeoutMs
+      },
+      status: "pending",
+      createdAt: now(),
+      updatedAt: now(),
+      startedAt: null,
+      endedAt: null,
+      logs: [],
+      result: null,
+      error: null,
+      cancelled: false,
+      backgroundMode: run ? "inline" : (config.background?.mode || "worker_process"),
+      workerPid: null,
+      lastHeartbeatAt: null,
+      attempt: Number(payload?.attempt || 1),
+      resumeToken: payload?.resumeToken || `resume_${Date.now()}`
+    }
+    await saveTask(task)
+
+    if (run) {
+      queueMicrotask(() => {
+        runInline(task, run).catch((err) => {
+          patchTask(task.id, () => ({
+            status: "error",
+            error: `inline task failed: ${err?.message || String(err)}`,
+            endedAt: now()
+          })).catch(() => {})
+        })
+      })
+      return task
+    }
+
+    await this.tick(config)
+    return (await loadTask(id)) || task
+  },
+
+  async launchDelegateTask({ description, payload, config = {} }) {
+    return this.launch({
+      description,
+      payload: {
+        ...payload,
+        workerType: "delegate_task",
+        attempt: Number(payload.attempt || 1),
+        resumeToken: payload.resumeToken || `resume_${Date.now()}`
+      },
+      run: null,
+      config
+    })
+  },
+
+  async get(id) {
+    await ensureBackgroundTaskRuntimeDir()
+    return loadTask(id)
+  },
+
+  async list() {
+    await ensureBackgroundTaskRuntimeDir()
+    return readAllTasks()
+  },
+
+  async cancel(id) {
+    const task = await loadTask(id)
+    if (!task) return false
+    await patchTask(id, (current) => ({
+      cancelled: true,
+      status: current.status === "pending" ? "cancelled" : current.status
+    }))
+    return true
+  },
+
+  async retry(id, config = {}) {
+    const task = await loadTask(id)
+    if (!task) return null
+    if (!["error", "interrupted"].includes(task.status)) return null
+
+    const nextAttempt = Number(task.attempt || 1) + 1
+    const nextResumeToken = `resume_${Date.now()}`
+    await patchTask(id, () => ({
+      status: "pending",
+      error: null,
+      cancelled: false,
+      endedAt: null,
+      workerPid: null,
+      lastHeartbeatAt: null,
+      attempt: nextAttempt,
+      resumeToken: nextResumeToken,
+      payload: {
+        ...(task.payload || {}),
+        attempt: nextAttempt,
+        resumeToken: nextResumeToken
+      }
+    }))
+
+    await this.tick(config)
+    return loadTask(id)
+  },
+
+  async clean({ maxAge = 7 * 24 * 60 * 60 * 1000 } = {}) {
+    const tasks = await readAllTasks()
+    const cutoff = now() - maxAge
+    const removed = []
+    for (const task of tasks) {
+      if (!TERMINAL_STATES.has(task.status)) continue
+      if (task.updatedAt > cutoff) continue
+      await unlink(backgroundTaskCheckpointPath(task.id)).catch(() => {})
+      await unlink(backgroundTaskLogPath(task.id)).catch(() => {})
+      removed.push(task.id)
+    }
+    return removed
+  },
+
+  async tick(config = {}) {
+    await markStaleRunningTasks(config)
+    await startPendingTasks(config)
+  }
+}

package/src/orchestration/background-worker.mjs

@@ -0,0 +1,245 @@
+import { appendFile } from "node:fs/promises"
+import { readJson, writeJson } from "../storage/json-store.mjs"
+import { ensureBackgroundTaskRuntimeDir, backgroundTaskCheckpointPath, backgroundTaskLogPath } from "../storage/paths.mjs"
+import { buildContext } from "../context.mjs"
+import { ToolRegistry } from "../tool/registry.mjs"
+import { executeTurn } from "../session/engine.mjs"
+
+function now() {
+  return Date.now()
+}
+
+function argValue(flag) {
+  const idx = process.argv.indexOf(flag)
+  if (idx < 0) return null
+  return process.argv[idx + 1] || null
+}
+
+function makeAbortError(reason = "aborted") {
+  const err = new Error(reason)
+  err.code = "ABORT_ERR"
+  return err
+}
+
+function isAbortError(error) {
+  return error?.code === "ABORT_ERR" || error?.name === "AbortError"
+}
+
+async function readTask(taskId) {
+  return readJson(backgroundTaskCheckpointPath(taskId), null)
+}
+
+async function patchTask(taskId, updater) {
+  const current = await readTask(taskId)
+  if (!current) return null
+  const next = {
+    ...current,
+    ...updater(current),
+    updatedAt: now()
+  }
+  await writeJson(backgroundTaskCheckpointPath(taskId), next)
+  return next
+}
+
+async function appendTaskLog(taskId, line) {
+  await appendFile(backgroundTaskLogPath(taskId), `${line}\n`, "utf8")
+  await patchTask(taskId, (current) => ({
+    logs: [...(current.logs || []), String(line)].slice(-300),
+    lastHeartbeatAt: now()
+  }))
+}
+
+async function runDelegateTask(task, signal) {
+  const payload = task.payload || {}
+  const cwd = payload.cwd || process.cwd()
+  process.chdir(cwd)
+
+  const ctx = await buildContext({ cwd })
+  await ToolRegistry.initialize({
+    config: ctx.configState.config,
+    cwd
+  })
+  const { CustomAgentRegistry } = await import("../agent/custom-agent-loader.mjs")
+  await CustomAgentRegistry.initialize(cwd)
+
+  const providerType = payload.providerType || ctx.configState.config.provider.default
+  const providerDefault = ctx.configState.config.provider[providerType]
+  const model = payload.model || providerDefault?.default_model
+
+  const out = await executeTurn({
+    prompt: String(payload.prompt || ""),
+    mode: "agent",
+    model,
+    providerType,
+    sessionId: payload.subSessionId,
+    configState: ctx.configState,
+    signal,
+    allowQuestion: payload.allowQuestion !== true ? false : true,
+    toolContext: {
+      taskId: task.id,
+      stageId: payload.stageId || null,
+      logicalTaskId: payload.logicalTaskId || null
+    }
+  })
+
+  const plannedFiles = Array.isArray(payload.plannedFiles)
+    ? payload.plannedFiles.map((item) => String(item || "").trim()).filter(Boolean)
+    : []
+  const completedFilesFromTools = out.toolEvents
+    .filter((event) => ["write", "edit"].includes(event.name) && event.status === "completed")
+    .map((event) => {
+      const p = event.args?.path
+      return p ? String(p).trim() : ""
+    })
+    .filter(Boolean)
+
+  const fileChanges = out.toolEvents
+    .flatMap((event) => Array.isArray(event?.metadata?.fileChanges) ? event.metadata.fileChanges : [])
+    .map((item) => ({
+      path: String(item?.path || "").trim(),
+      addedLines: Math.max(0, Number(item?.addedLines || 0)),
+      removedLines: Math.max(0, Number(item?.removedLines || 0)),
+      stageId: item?.stageId ? String(item.stageId) : (payload.stageId || ""),
+      taskId: item?.taskId ? String(item.taskId) : (payload.logicalTaskId || "")
+    }))
+    .filter((item) => item.path)
+
+  const completedFileSet = new Set(
+    completedFilesFromTools.filter((file) => plannedFiles.length === 0 || plannedFiles.includes(file))
+  )
+  const completedFiles = [...completedFileSet]
+  const remainingFiles = plannedFiles.filter((file) => !completedFileSet.has(file))
+
+  return {
+    session_id: payload.subSessionId,
+    parent_session_id: payload.parentSessionId || null,
+    subagent: payload.subagent || null,
+    reply: out.reply,
+    tool_events: out.toolEvents?.length || 0,
+    completed_files: completedFiles,
+    remaining_files: remainingFiles,
+    file_changes: fileChanges,
+    cost: out.cost,
+    budget_warnings: out.budgetWarnings || []
+  }
+}
+
+async function main() {
+  const taskId = argValue("--task-id") || process.env.KKCODE_BACKGROUND_TASK_ID || null
+  if (!taskId) {
+    process.exit(1)
+    return
+  }
+
+  await ensureBackgroundTaskRuntimeDir()
+  const task = await readTask(taskId)
+  if (!task) {
+    process.exit(1)
+    return
+  }
+
+  if (task.cancelled) {
+    await patchTask(taskId, () => ({
+      status: "cancelled",
+      endedAt: now()
+    }))
+    process.exit(0)
+    return
+  }
+
+  await patchTask(taskId, () => ({
+    status: "running",
+    workerPid: process.pid,
+    startedAt: now(),
+    lastHeartbeatAt: now()
+  }))
+
+  const abortController = new AbortController()
+  const parentPid = process.ppid
+  const heartbeatTimer = setInterval(() => {
+    patchTask(taskId, () => ({ lastHeartbeatAt: now() })).catch(() => {})
+  }, 2000)
+
+  const cancelPoll = setInterval(() => {
+    // Orphan detection: if parent process died, self-terminate
+    try { process.kill(parentPid, 0) } catch {
+      if (!abortController.signal.aborted) {
+        abortController.abort(makeAbortError("parent process exited, worker orphaned"))
+      }
+      return
+    }
+    readTask(taskId).then((latest) => {
+      if (latest?.cancelled && !abortController.signal.aborted) {
+        abortController.abort(makeAbortError("cancelled by user"))
+      }
+    }).catch(() => {})
+  }, 1500)
+
+  const timeoutMs = Math.max(1000, Number(task.payload?.workerTimeoutMs || 900000))
+  const timeoutTimer = setTimeout(() => {
+    if (!abortController.signal.aborted) {
+      abortController.abort(makeAbortError(`worker timeout after ${timeoutMs}ms`))
+    }
+  }, timeoutMs)
+
+  try {
+    await appendTaskLog(taskId, `task started (worker pid=${process.pid})`)
+
+    const latest = await readTask(taskId)
+    if (!latest?.payload?.workerType || latest.payload.workerType !== "delegate_task") {
+      throw new Error(`unsupported workerType: ${latest?.payload?.workerType || "unknown"}`)
+    }
+
+    const result = await runDelegateTask(latest, abortController.signal)
+    await appendTaskLog(taskId, "task completed")
+    await patchTask(taskId, () => ({
+      status: "completed",
+      result,
+      error: null,
+      endedAt: now(),
+      lastHeartbeatAt: now()
+    }))
+    process.exit(0)
+  } catch (error) {
+    const latest = await readTask(taskId)
+    const cancelled = latest?.cancelled
+    const aborted = isAbortError(error)
+    if (cancelled) {
+      await appendTaskLog(taskId, "task cancelled")
+      await patchTask(taskId, () => ({
+        status: "cancelled",
+        endedAt: now(),
+        error: null
+      }))
+      process.exit(0)
+      return
+    }
+
+    if (aborted) {
+      await appendTaskLog(taskId, `task interrupted: ${error.message}`)
+      await patchTask(taskId, () => ({
+        status: "interrupted",
+        error: error.message,
+        endedAt: now()
+      }))
+      process.exit(2)
+      return
+    }
+
+    await appendTaskLog(taskId, `task error: ${error.message}`)
+    await patchTask(taskId, () => ({
+      status: "error",
+      error: error.message,
+      endedAt: now()
+    }))
+    process.exit(1)
+  } finally {
+    clearInterval(heartbeatTimer)
+    clearInterval(cancelPoll)
+    clearTimeout(timeoutTimer)
+  }
+}
+
+main().catch(() => {
+  process.exit(1)
+})

package/src/orchestration/longagent-manager.mjs

@@ -0,0 +1,116 @@
+import path from "node:path"
+import { mkdir, writeFile, unlink, stat } from "node:fs/promises"
+import { readJson, writeJson } from "../storage/json-store.mjs"
+import { projectRootDir } from "../storage/paths.mjs"
+
+function statePath(cwd = process.cwd()) {
+  return path.join(projectRootDir(cwd), "longagent-state.json")
+}
+
+function lockPath(cwd = process.cwd()) {
+  return statePath(cwd) + ".lock"
+}
+
+async function ensure(cwd = process.cwd()) {
+  await mkdir(projectRootDir(cwd), { recursive: true })
+}
+
+const LOCK_TIMEOUT_MS = 5000
+const LOCK_RETRY_MS = 50
+
+async function acquireLock(cwd) {
+  const file = lockPath(cwd)
+  const deadline = Date.now() + LOCK_TIMEOUT_MS
+  while (Date.now() < deadline) {
+    try {
+      await writeFile(file, String(process.pid), { flag: "wx" })
+      return true
+    } catch (err) {
+      if (err.code !== "EEXIST") throw err
+      // Stale lock detection: if lock file is older than timeout, remove it
+      try {
+        const info = await stat(file)
+        if (Date.now() - info.mtimeMs > LOCK_TIMEOUT_MS) {
+          await unlink(file).catch(() => {})
+          continue
+        }
+      } catch { /* lock disappeared, retry */ continue }
+      await new Promise((r) => setTimeout(r, LOCK_RETRY_MS))
+    }
+  }
+  // Timeout: force-remove stale lock and proceed
+  await unlink(file).catch(() => {})
+  return false
+}
+
+async function releaseLock(cwd) {
+  await unlink(lockPath(cwd)).catch(() => {})
+}
+
+async function read(cwd = process.cwd()) {
+  await ensure(cwd)
+  return readJson(statePath(cwd), { sessions: {} })
+}
+
+async function write(data, cwd = process.cwd()) {
+  await ensure(cwd)
+  await writeJson(statePath(cwd), data)
+}
+
+export const LongAgentManager = {
+  async update(sessionId, patch, cwd = process.cwd()) {
+    await acquireLock(cwd)
+    try {
+      const state = await read(cwd)
+      const current = state.sessions[sessionId] || {
+        sessionId,
+        status: "idle",
+        phase: "L0",
+        gateStatus: {},
+        currentGate: "execution",
+        recoveryCount: 0,
+        planFrozen: false,
+        currentStageId: null,
+        stageIndex: 0,
+        stageCount: 0,
+        stageStatus: null,
+        taskProgress: {},
+        remainingFiles: [],
+        remainingFilesCount: 0,
+        lastGateFailures: [],
+        createdAt: Date.now(),
+        updatedAt: Date.now(),
+        heartbeatAt: null,
+        iterations: 0,
+        lastMessage: ""
+      }
+      state.sessions[sessionId] = {
+        ...current,
+        ...patch,
+        updatedAt: Date.now()
+      }
+      await write(state, cwd)
+      return state.sessions[sessionId]
+    } finally {
+      await releaseLock(cwd)
+    }
+  },
+  async get(sessionId, cwd = process.cwd()) {
+    const state = await read(cwd)
+    return state.sessions[sessionId] || null
+  },
+  async list(cwd = process.cwd()) {
+    const state = await read(cwd)
+    return Object.values(state.sessions).sort((a, b) => b.updatedAt - a.updatedAt)
+  },
+  async stop(sessionId, cwd = process.cwd()) {
+    const existing = await this.get(sessionId, cwd)
+    if (!existing) return null
+    return this.update(sessionId, { stopRequested: true }, cwd)
+  },
+  async clearStop(sessionId, cwd = process.cwd()) {
+    const existing = await this.get(sessionId, cwd)
+    if (!existing) return null
+    return this.update(sessionId, { stopRequested: false }, cwd)
+  }
+}