@jjlabsio/claude-crew 0.1.31 → 0.1.32

package/scripts/crew-codex/lib/state.mjs

@@ -0,0 +1,424 @@
+// SPDX-License-Identifier: Apache-2.0
+// Derived from @openai/codex-plugin-cc and modified for claude-crew.
+import { createHash } from "node:crypto";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+import { resolveWorkspaceRoot } from "./workspace.mjs";
+
+const STATE_VERSION = 1;
+const PLUGIN_DATA_ENV = "CLAUDE_PLUGIN_DATA";
+const FALLBACK_STATE_ROOT_DIR = path.join(os.tmpdir(), "crew-codex-companion");
+const STATE_FILE_NAME = "state.json";
+const JOBS_DIR_NAME = "jobs";
+const LOCK_DIR_NAME = ".lock";
+const LOCK_WAIT_TIMEOUT_MS = 10000;
+const LOCK_POLL_INTERVAL_MS = 50;
+const LOCK_STALE_AFTER_MS = 60000;
+const MAX_JOBS = 50;
+
+function nowIso() {
+  return new Date().toISOString();
+}
+
+function defaultState() {
+  return {
+    version: STATE_VERSION,
+    config: {
+      stopReviewGate: false
+    },
+    jobs: []
+  };
+}
+
+export function resolveStateDir(cwd) {
+  const workspaceRoot = resolveWorkspaceRoot(cwd);
+  let canonicalWorkspaceRoot = workspaceRoot;
+  try {
+    canonicalWorkspaceRoot = fs.realpathSync.native(workspaceRoot);
+  } catch {
+    canonicalWorkspaceRoot = workspaceRoot;
+  }
+
+  const slugSource = path.basename(workspaceRoot) || "workspace";
+  const slug = slugSource.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "workspace";
+  const hash = createHash("sha256").update(canonicalWorkspaceRoot).digest("hex").slice(0, 16);
+  const pluginDataDir = process.env[PLUGIN_DATA_ENV];
+  const stateRoot = pluginDataDir ? path.join(pluginDataDir, "state") : FALLBACK_STATE_ROOT_DIR;
+  return path.join(stateRoot, `${slug}-${hash}`);
+}
+
+export function resolveStateFile(cwd) {
+  return path.join(resolveStateDir(cwd), STATE_FILE_NAME);
+}
+
+export function resolveJobsDir(cwd) {
+  return path.join(resolveStateDir(cwd), JOBS_DIR_NAME);
+}
+
+export function ensureStateDir(cwd) {
+  fs.mkdirSync(resolveJobsDir(cwd), { recursive: true });
+}
+
+function sleepSync(ms) {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function resolveLockDir(cwd) {
+  return path.join(resolveStateDir(cwd), LOCK_DIR_NAME);
+}
+
+function writeLockOwner(lockDir) {
+  fs.writeFileSync(
+    path.join(lockDir, "owner.json"),
+    `${JSON.stringify({ pid: process.pid, createdAt: nowIso() }, null, 2)}\n`,
+    "utf8"
+  );
+}
+
+function readLockOwner(lockDir) {
+  try {
+    return JSON.parse(fs.readFileSync(path.join(lockDir, "owner.json"), "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function isProcessAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) {
+    return false;
+  }
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error?.code === "EPERM";
+  }
+}
+
+function getLockAgeMs(lockDir, owner) {
+  const createdAt = Date.parse(owner?.createdAt ?? "");
+  if (Number.isFinite(createdAt)) {
+    return Date.now() - createdAt;
+  }
+  try {
+    return Date.now() - fs.statSync(lockDir).mtimeMs;
+  } catch {
+    return 0;
+  }
+}
+
+function removeStaleLock(lockDir, owner) {
+  try {
+    fs.rmSync(lockDir, { recursive: true, force: true });
+  } catch (error) {
+    throw new Error(
+      `Failed to remove stale Codex companion state lock held by pid ${owner?.pid ?? "unknown"}: ${
+        error instanceof Error ? error.message : String(error)
+      }`
+    );
+  }
+}
+
+function maybeRemoveStaleLock(lockDir, options = {}) {
+  const staleAfterMs = options.staleAfterMs ?? LOCK_STALE_AFTER_MS;
+  const owner = readLockOwner(lockDir);
+  const ageMs = getLockAgeMs(lockDir, owner);
+
+  if (!owner) {
+    if (ageMs >= staleAfterMs) {
+      removeStaleLock(lockDir, owner);
+      return true;
+    }
+    return false;
+  }
+
+  if (!isProcessAlive(owner.pid) || ageMs >= staleAfterMs) {
+    removeStaleLock(lockDir, owner);
+    return true;
+  }
+  return false;
+}
+
+function acquireStateLock(cwd, options = {}) {
+  const timeoutMs = options.timeoutMs ?? LOCK_WAIT_TIMEOUT_MS;
+  const pollIntervalMs = options.pollIntervalMs ?? LOCK_POLL_INTERVAL_MS;
+  const stateDir = resolveStateDir(cwd);
+  const lockDir = resolveLockDir(cwd);
+  const startedAt = Date.now();
+  fs.mkdirSync(stateDir, { recursive: true });
+
+  while (true) {
+    try {
+      fs.mkdirSync(lockDir);
+      writeLockOwner(lockDir);
+      return lockDir;
+    } catch (error) {
+      if (error?.code !== "EEXIST") {
+        throw error;
+      }
+      if (Date.now() - startedAt >= timeoutMs) {
+        throw new Error(`Timed out waiting for Codex companion state lock: ${lockDir}`);
+      }
+      if (maybeRemoveStaleLock(lockDir, options)) {
+        continue;
+      }
+      sleepSync(pollIntervalMs);
+    }
+  }
+}
+
+async function acquireStateLockAsync(cwd, options = {}) {
+  const timeoutMs = options.timeoutMs ?? LOCK_WAIT_TIMEOUT_MS;
+  const pollIntervalMs = options.pollIntervalMs ?? LOCK_POLL_INTERVAL_MS;
+  const stateDir = resolveStateDir(cwd);
+  const lockDir = resolveLockDir(cwd);
+  const startedAt = Date.now();
+  fs.mkdirSync(stateDir, { recursive: true });
+
+  while (true) {
+    try {
+      fs.mkdirSync(lockDir);
+      writeLockOwner(lockDir);
+      return lockDir;
+    } catch (error) {
+      if (error?.code !== "EEXIST") {
+        throw error;
+      }
+      if (Date.now() - startedAt >= timeoutMs) {
+        throw new Error(`Timed out waiting for Codex companion state lock: ${lockDir}`);
+      }
+      if (maybeRemoveStaleLock(lockDir, options)) {
+        continue;
+      }
+      await sleep(pollIntervalMs);
+    }
+  }
+}
+
+function releaseStateLock(lockDir) {
+  try {
+    fs.rmSync(lockDir, { recursive: true, force: true });
+  } catch {
+    // Lock release is best-effort; callers should not fail after their write completed.
+  }
+}
+
+export function withStateLock(cwd, callback, options = {}) {
+  const lockDir = acquireStateLock(cwd, options);
+  try {
+    return callback();
+  } finally {
+    releaseStateLock(lockDir);
+  }
+}
+
+export async function withStateLockAsync(cwd, callback, options = {}) {
+  const lockDir = await acquireStateLockAsync(cwd, options);
+  try {
+    return await callback();
+  } finally {
+    releaseStateLock(lockDir);
+  }
+}
+
+export function loadState(cwd) {
+  const stateFile = resolveStateFile(cwd);
+  if (!fs.existsSync(stateFile)) {
+    return defaultState();
+  }
+
+  try {
+    const parsed = JSON.parse(fs.readFileSync(stateFile, "utf8"));
+    return {
+      ...defaultState(),
+      ...parsed,
+      config: {
+        ...defaultState().config,
+        ...(parsed.config ?? {})
+      },
+      jobs: Array.isArray(parsed.jobs) ? parsed.jobs : []
+    };
+  } catch {
+    return defaultState();
+  }
+}
+
+function pruneJobs(jobs) {
+  return [...jobs]
+    .sort((left, right) => String(right.updatedAt ?? "").localeCompare(String(left.updatedAt ?? "")))
+    .slice(0, MAX_JOBS);
+}
+
+function removeFileIfExists(filePath) {
+  if (filePath && fs.existsSync(filePath)) {
+    fs.unlinkSync(filePath);
+  }
+}
+
+export function writeJsonFileAtomic(filePath, payload) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  const tempPath = path.join(
+    path.dirname(filePath),
+    `.${path.basename(filePath)}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`
+  );
+  fs.writeFileSync(tempPath, `${JSON.stringify(payload, null, 2)}\n`, "utf8");
+  fs.renameSync(tempPath, filePath);
+}
+
+function saveStateUnlocked(cwd, state) {
+  const previousJobs = loadState(cwd).jobs;
+  ensureStateDir(cwd);
+  const nextJobs = pruneJobs(state.jobs ?? []);
+  const nextState = {
+    version: STATE_VERSION,
+    config: {
+      ...defaultState().config,
+      ...(state.config ?? {})
+    },
+    jobs: nextJobs
+  };
+
+  const retainedIds = new Set(nextJobs.map((job) => job.id));
+  for (const job of previousJobs) {
+    if (retainedIds.has(job.id)) {
+      continue;
+    }
+    removeJobFile(resolveJobFile(cwd, job.id));
+    removeFileIfExists(job.logFile);
+  }
+
+  writeJsonFileAtomic(resolveStateFile(cwd), nextState);
+  return nextState;
+}
+
+export function saveState(cwd, state) {
+  return withStateLock(cwd, () => saveStateUnlocked(cwd, state));
+}
+
+export function updateState(cwd, mutate) {
+  return withStateLock(cwd, () => {
+    const state = loadState(cwd);
+    mutate(state);
+    return saveStateUnlocked(cwd, state);
+  });
+}
+
+export function generateJobId(prefix = "job") {
+  const random = Math.random().toString(36).slice(2, 8);
+  return `${prefix}-${Date.now().toString(36)}-${random}`;
+}
+
+export function upsertJob(cwd, jobPatch) {
+  return updateState(cwd, (state) => {
+    const timestamp = nowIso();
+    const existingIndex = state.jobs.findIndex((job) => job.id === jobPatch.id);
+    if (existingIndex === -1) {
+      state.jobs.unshift({
+        createdAt: timestamp,
+        updatedAt: timestamp,
+        ...jobPatch
+      });
+      return;
+    }
+    state.jobs[existingIndex] = {
+      ...state.jobs[existingIndex],
+      ...jobPatch,
+      updatedAt: timestamp
+    };
+  });
+}
+
+export function updateJobStateAndFile(cwd, jobId, mutate) {
+  return withStateLock(cwd, () => {
+    const state = loadState(cwd);
+    const timestamp = nowIso();
+    const existingIndex = state.jobs.findIndex((job) => job.id === jobId);
+    const existingJob = existingIndex === -1 ? null : state.jobs[existingIndex];
+    const result = mutate(existingJob, { timestamp });
+    if (!result) {
+      return null;
+    }
+
+    const stateJob = result.stateJob ?? result.job ?? null;
+    if (!stateJob) {
+      return null;
+    }
+
+    const nextStateJob = {
+      ...(existingJob ?? {
+        createdAt: timestamp
+      }),
+      ...stateJob,
+      id: jobId,
+      updatedAt: stateJob.updatedAt ?? timestamp
+    };
+
+    if (existingIndex === -1) {
+      state.jobs.unshift(nextStateJob);
+    } else {
+      state.jobs[existingIndex] = nextStateJob;
+    }
+
+    const nextState = saveStateUnlocked(cwd, state);
+    const fileJob = result.fileJob ?? nextStateJob;
+    if (fileJob) {
+      writeJsonFileAtomic(resolveJobFile(cwd, jobId), fileJob);
+    }
+
+    return {
+      state: nextState,
+      job: nextStateJob,
+      fileJob
+    };
+  });
+}
+
+export function listJobs(cwd) {
+  return loadState(cwd).jobs;
+}
+
+export function setConfig(cwd, key, value) {
+  return updateState(cwd, (state) => {
+    state.config = {
+      ...state.config,
+      [key]: value
+    };
+  });
+}
+
+export function getConfig(cwd) {
+  return loadState(cwd).config;
+}
+
+export function writeJobFile(cwd, jobId, payload) {
+  ensureStateDir(cwd);
+  const jobFile = resolveJobFile(cwd, jobId);
+  writeJsonFileAtomic(jobFile, payload);
+  return jobFile;
+}
+
+export function readJobFile(jobFile) {
+  return JSON.parse(fs.readFileSync(jobFile, "utf8"));
+}
+
+function removeJobFile(jobFile) {
+  if (fs.existsSync(jobFile)) {
+    fs.unlinkSync(jobFile);
+  }
+}
+
+export function resolveJobLogFile(cwd, jobId) {
+  ensureStateDir(cwd);
+  return path.join(resolveJobsDir(cwd), `${jobId}.log`);
+}
+
+export function resolveJobFile(cwd, jobId) {
+  ensureStateDir(cwd);
+  return path.join(resolveJobsDir(cwd), `${jobId}.json`);
+}

package/scripts/crew-codex/lib/tracked-jobs.mjs

@@ -0,0 +1,279 @@
+// SPDX-License-Identifier: Apache-2.0
+// Derived from @openai/codex-plugin-cc and modified for claude-crew.
+import fs from "node:fs";
+import process from "node:process";
+
+import { readJobFile, resolveJobFile, resolveJobLogFile, updateJobStateAndFile } from "./state.mjs";
+
+export const SESSION_ID_ENV = "CODEX_COMPANION_SESSION_ID";
+
+export function nowIso() {
+  return new Date().toISOString();
+}
+
+function normalizeProgressEvent(value) {
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    return {
+      message: String(value.message ?? "").trim(),
+      phase: typeof value.phase === "string" && value.phase.trim() ? value.phase.trim() : null,
+      threadId: typeof value.threadId === "string" && value.threadId.trim() ? value.threadId.trim() : null,
+      turnId: typeof value.turnId === "string" && value.turnId.trim() ? value.turnId.trim() : null,
+      stderrMessage: value.stderrMessage == null ? null : String(value.stderrMessage).trim(),
+      logTitle: typeof value.logTitle === "string" && value.logTitle.trim() ? value.logTitle.trim() : null,
+      logBody: value.logBody == null ? null : String(value.logBody).trimEnd()
+    };
+  }
+
+  return {
+    message: String(value ?? "").trim(),
+    phase: null,
+    threadId: null,
+    turnId: null,
+    stderrMessage: String(value ?? "").trim(),
+    logTitle: null,
+    logBody: null
+  };
+}
+
+export function appendLogLine(logFile, message) {
+  const normalized = String(message ?? "").trim();
+  if (!logFile || !normalized) {
+    return;
+  }
+  fs.appendFileSync(logFile, `[${nowIso()}] ${normalized}\n`, "utf8");
+}
+
+export function appendLogBlock(logFile, title, body) {
+  if (!logFile || !body) {
+    return;
+  }
+  fs.appendFileSync(logFile, `\n[${nowIso()}] ${title}\n${String(body).trimEnd()}\n`, "utf8");
+}
+
+export function createJobLogFile(workspaceRoot, jobId, title) {
+  const logFile = resolveJobLogFile(workspaceRoot, jobId);
+  fs.writeFileSync(logFile, "", "utf8");
+  if (title) {
+    appendLogLine(logFile, `Starting ${title}.`);
+  }
+  return logFile;
+}
+
+export function createJobRecord(base, options = {}) {
+  const env = options.env ?? process.env;
+  const sessionId = env[options.sessionIdEnv ?? SESSION_ID_ENV];
+  return {
+    ...base,
+    createdAt: nowIso(),
+    ...(sessionId ? { sessionId } : {})
+  };
+}
+
+export function createJobProgressUpdater(workspaceRoot, jobId) {
+  let lastPhase = null;
+  let lastThreadId = null;
+  let lastTurnId = null;
+
+  return (event) => {
+    const normalized = normalizeProgressEvent(event);
+    const patch = { id: jobId };
+    let changed = false;
+
+    if (normalized.phase && normalized.phase !== lastPhase) {
+      lastPhase = normalized.phase;
+      patch.phase = normalized.phase;
+      changed = true;
+    }
+
+    if (normalized.threadId && normalized.threadId !== lastThreadId) {
+      lastThreadId = normalized.threadId;
+      patch.threadId = normalized.threadId;
+      changed = true;
+    }
+
+    if (normalized.turnId && normalized.turnId !== lastTurnId) {
+      lastTurnId = normalized.turnId;
+      patch.turnId = normalized.turnId;
+      changed = true;
+    }
+
+    if (!changed) {
+      return;
+    }
+
+    updateJobStateAndFile(workspaceRoot, jobId, (existing) => {
+      if (!existing || existing.status === "completed" || existing.status === "failed" || existing.status === "cancelled") {
+        return null;
+      }
+
+      const jobFile = resolveJobFile(workspaceRoot, jobId);
+      const storedJob = fs.existsSync(jobFile) ? readJobFile(jobFile) : existing;
+      return {
+        stateJob: {
+          ...patch,
+          phase: patch.phase ?? existing.phase
+        },
+        fileJob: {
+          ...storedJob,
+          ...patch,
+          phase: patch.phase ?? storedJob.phase
+        }
+      };
+    });
+  };
+}
+
+export function createProgressReporter({ stderr = false, logFile = null, onEvent = null } = {}) {
+  if (!stderr && !logFile && !onEvent) {
+    return null;
+  }
+
+  return (eventOrMessage) => {
+    const event = normalizeProgressEvent(eventOrMessage);
+    const stderrMessage = event.stderrMessage ?? event.message;
+    if (stderr && stderrMessage) {
+      process.stderr.write(`[codex] ${stderrMessage}\n`);
+    }
+    appendLogLine(logFile, event.message);
+    appendLogBlock(logFile, event.logTitle, event.logBody);
+    onEvent?.(event);
+  };
+}
+
+function readStoredJobOrNull(workspaceRoot, jobId) {
+  const jobFile = resolveJobFile(workspaceRoot, jobId);
+  if (!fs.existsSync(jobFile)) {
+    return null;
+  }
+  return readJobFile(jobFile);
+}
+
+function updateActiveRunningJob(workspaceRoot, jobId, pid, patch, fileJob = null) {
+  const updated = updateJobStateAndFile(workspaceRoot, jobId, (existing) => {
+    if (!existing || existing.status !== "running" || existing.pid !== pid) {
+      return null;
+    }
+
+    return {
+      stateJob: patch,
+      ...(fileJob ? { fileJob } : {})
+    };
+  });
+  return Boolean(updated);
+}
+
+function markJobRunning(workspaceRoot, runningRecord) {
+  const updated = updateJobStateAndFile(workspaceRoot, runningRecord.id, (existing, { timestamp }) => {
+    if (existing && existing.status !== "queued") {
+      return null;
+    }
+
+    return {
+      stateJob: {
+        ...runningRecord,
+        updatedAt: timestamp
+      },
+      fileJob: runningRecord
+    };
+  });
+  return Boolean(updated);
+}
+
+export async function runTrackedJob(job, runner, options = {}) {
+  const runningRecord = {
+    ...job,
+    status: "running",
+    startedAt: nowIso(),
+    phase: "starting",
+    pid: process.pid,
+    logFile: options.logFile ?? job.logFile ?? null
+  };
+  const started = markJobRunning(job.workspaceRoot, runningRecord);
+  if (!started) {
+    appendLogLine(options.logFile ?? job.logFile ?? null, "Job was no longer queued; skipping worker execution.");
+    return {
+      exitStatus: 1,
+      threadId: job.threadId ?? null,
+      turnId: job.turnId ?? null,
+      payload: {
+        status: 1,
+        errorMessage: "Job was no longer queued; skipping worker execution."
+      },
+      rendered: "Job was no longer queued; skipping worker execution.\n",
+      summary: "Job skipped because it was no longer queued."
+    };
+  }
+
+  try {
+    const execution = await runner();
+    const completionStatus = execution.exitStatus === 0 ? "completed" : "failed";
+    const completedAt = nowIso();
+    const completionPatch = {
+      status: completionStatus,
+      threadId: execution.threadId ?? null,
+      turnId: execution.turnId ?? null,
+      summary: execution.summary,
+      phase: completionStatus === "completed" ? "done" : "failed",
+      pid: null,
+      completedAt,
+      updatedAt: completedAt
+    };
+    const completedFileJob = {
+      ...runningRecord,
+      status: completionStatus,
+      threadId: execution.threadId ?? null,
+      turnId: execution.turnId ?? null,
+      pid: null,
+      phase: completionStatus === "completed" ? "done" : "failed",
+      completedAt,
+      result: execution.payload,
+      rendered: execution.rendered
+    };
+    const transitioned = updateActiveRunningJob(
+      job.workspaceRoot,
+      job.id,
+      process.pid,
+      completionPatch,
+      completedFileJob
+    );
+    if (!transitioned) {
+      appendLogLine(options.logFile ?? job.logFile ?? null, "Job was no longer active at completion; preserving current job state.");
+      return execution;
+    }
+    appendLogBlock(options.logFile ?? job.logFile ?? null, "Final output", execution.rendered);
+    return execution;
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    const existing = readStoredJobOrNull(job.workspaceRoot, job.id) ?? runningRecord;
+    const completedAt = nowIso();
+    const failurePatch = {
+      status: "failed",
+      phase: "failed",
+      pid: null,
+      errorMessage,
+      completedAt,
+      updatedAt: completedAt
+    };
+    const failedFileJob = {
+      ...existing,
+      status: "failed",
+      phase: "failed",
+      errorMessage,
+      pid: null,
+      completedAt,
+      logFile: options.logFile ?? job.logFile ?? existing.logFile ?? null
+    };
+    const transitioned = updateActiveRunningJob(
+      job.workspaceRoot,
+      job.id,
+      process.pid,
+      failurePatch,
+      failedFileJob
+    );
+    if (!transitioned) {
+      appendLogLine(options.logFile ?? job.logFile ?? null, "Job was no longer active after failure; preserving current job state.");
+      throw error;
+    }
+    throw error;
+  }
+}

package/scripts/crew-codex/lib/workspace.mjs

@@ -0,0 +1,11 @@
+// SPDX-License-Identifier: Apache-2.0
+// Derived from @openai/codex-plugin-cc and modified for claude-crew.
+import { ensureGitRepository } from "./git.mjs";
+
+export function resolveWorkspaceRoot(cwd) {
+  try {
+    return ensureGitRepository(cwd);
+  } catch {
+    return cwd;
+  }
+}