dsh-plugin-cc 0.1.0

package/plugins/dsh/scripts/lib/job-control.mjs

@@ -0,0 +1,314 @@
+import fs from "node:fs";
+
+import { isProcessAlive, terminateProcessTree } from "./process.mjs";
+import { listJobs, readJobFile, resolveJobFile, upsertJob, withStateLock, writeJobFile } from "./state.mjs";
+import { nowIso, SESSION_ID_ENV } from "./tracked-jobs.mjs";
+import { resolveWorkspaceRoot } from "./workspace.mjs";
+
+export const DEFAULT_MAX_STATUS_JOBS = 8;
+export const DEFAULT_MAX_PROGRESS_LINES = 4;
+
+/**
+ * Marks active jobs whose companion process has died (for example after SIGKILL) as failed and stops
+ * any dsh process group they left behind, so they cannot block resume or hide from cancel.
+ */
+export function reconcileStaleJobs(workspaceRoot) {
+  withStateLock(workspaceRoot, () => {
+    for (const job of listJobs(workspaceRoot)) {
+      const active = job.status === "queued" || job.status === "running";
+      if (!active || !Number.isFinite(job.pid) || isProcessAlive(job.pid)) {
+        continue;
+      }
+      const failure = {
+        status: "failed",
+        phase: "failed",
+        pid: null,
+        errorMessage: "The companion process ended unexpectedly.",
+        completedAt: nowIso()
+      };
+      const jobFile = resolveJobFile(workspaceRoot, job.id);
+      const stored = fs.existsSync(jobFile) ? readJobFile(jobFile) : job;
+      writeJobFile(workspaceRoot, job.id, { ...stored, ...failure });
+      upsertJob(workspaceRoot, { id: job.id, ...failure });
+      if (Number.isFinite(job.dshPid)) {
+        terminateProcessTree(job.dshPid);
+      }
+    }
+  });
+}
+
+export function sortJobsNewestFirst(jobs) {
+  return [...jobs].sort((left, right) => String(right.updatedAt ?? "").localeCompare(String(left.updatedAt ?? "")));
+}
+
+function getCurrentSessionId(options = {}) {
+  return options.env?.[SESSION_ID_ENV] ?? process.env[SESSION_ID_ENV] ?? null;
+}
+
+function filterJobsForCurrentSession(jobs, options = {}) {
+  const sessionId = getCurrentSessionId(options);
+  if (!sessionId) {
+    return jobs;
+  }
+  return jobs.filter((job) => job.sessionId === sessionId);
+}
+
+function getJobTypeLabel(job) {
+  if (typeof job.kindLabel === "string" && job.kindLabel) {
+    return job.kindLabel;
+  }
+  if (job.kind === "plan" || job.kind === "review-plan") {
+    return job.kind;
+  }
+  if (job.kind === "task") {
+    return "rescue";
+  }
+  return "job";
+}
+
+function stripLogPrefix(line) {
+  return line.replace(/^\[[^\]]+\]\s*/, "").trim();
+}
+
+function isProgressBlockTitle(line) {
+  return (
+    line === "Final output"
+  );
+}
+
+export function readJobProgressPreview(logFile, maxLines = DEFAULT_MAX_PROGRESS_LINES) {
+  if (!logFile || !fs.existsSync(logFile)) {
+    return [];
+  }
+
+  const lines = fs
+    .readFileSync(logFile, "utf8")
+    .split(/\r?\n/)
+    .map((line) => line.trimEnd())
+    .filter(Boolean)
+    .filter((line) => line.startsWith("["))
+    .map(stripLogPrefix)
+    .filter((line) => line && !isProgressBlockTitle(line));
+
+  return lines.slice(-maxLines);
+}
+
+function formatElapsedDuration(startValue, endValue = null) {
+  const start = Date.parse(startValue ?? "");
+  if (!Number.isFinite(start)) {
+    return null;
+  }
+
+  const end = endValue ? Date.parse(endValue) : Date.now();
+  if (!Number.isFinite(end) || end < start) {
+    return null;
+  }
+
+  const totalSeconds = Math.max(0, Math.round((end - start) / 1000));
+  const hours = Math.floor(totalSeconds / 3600);
+  const minutes = Math.floor((totalSeconds % 3600) / 60);
+  const seconds = totalSeconds % 60;
+
+  if (hours > 0) {
+    return `${hours}h ${minutes}m`;
+  }
+  if (minutes > 0) {
+    return `${minutes}m ${seconds}s`;
+  }
+  return `${seconds}s`;
+}
+
+function inferLegacyJobPhase(job) {
+  switch (job.status) {
+    case "queued":
+      return "queued";
+    case "cancelled":
+      return "cancelled";
+    case "failed":
+      return "failed";
+    case "completed":
+      return "done";
+    default:
+      return "running";
+  }
+}
+
+export function enrichJob(job, options = {}) {
+  const maxProgressLines = options.maxProgressLines ?? DEFAULT_MAX_PROGRESS_LINES;
+  const enriched = {
+    ...job,
+    kindLabel: getJobTypeLabel(job),
+    progressPreview:
+      job.status === "queued" || job.status === "running" || job.status === "failed"
+        ? readJobProgressPreview(job.logFile, maxProgressLines)
+        : [],
+    elapsed: formatElapsedDuration(job.startedAt ?? job.createdAt, job.completedAt ?? null),
+    duration:
+      job.status === "completed" || job.status === "failed" || job.status === "cancelled"
+        ? formatElapsedDuration(job.startedAt ?? job.createdAt, job.completedAt ?? job.updatedAt)
+        : null
+  };
+
+  return {
+    ...enriched,
+    phase: enriched.phase ?? inferLegacyJobPhase(enriched)
+  };
+}
+
+export function readStoredJob(workspaceRoot, jobId) {
+  const jobFile = resolveJobFile(workspaceRoot, jobId);
+  if (!fs.existsSync(jobFile)) {
+    return null;
+  }
+  return readJobFile(jobFile);
+}
+
+function matchJobReference(jobs, reference, predicate = () => true) {
+  const filtered = jobs.filter(predicate);
+  if (!reference) {
+    return filtered[0] ?? null;
+  }
+
+  const exact = filtered.find((job) => job.id === reference);
+  if (exact) {
+    return exact;
+  }
+
+  const prefixMatches = filtered.filter((job) => job.id.startsWith(reference));
+  if (prefixMatches.length === 1) {
+    return prefixMatches[0];
+  }
+  if (prefixMatches.length > 1) {
+    throw new Error(`Job reference "${reference}" is ambiguous. Use a longer job id.`);
+  }
+
+  throw new Error(`No job found for "${reference}". Run /dsh:status to list known jobs.`);
+}
+
+export function buildStatusSnapshot(cwd, options = {}) {
+  const workspaceRoot = resolveWorkspaceRoot(cwd);
+  reconcileStaleJobs(workspaceRoot);
+  const jobs = sortJobsNewestFirst(filterJobsForCurrentSession(listJobs(workspaceRoot), options));
+  const maxJobs = options.maxJobs ?? DEFAULT_MAX_STATUS_JOBS;
+  const maxProgressLines = options.maxProgressLines ?? DEFAULT_MAX_PROGRESS_LINES;
+
+  const running = jobs
+    .filter((job) => job.status === "queued" || job.status === "running")
+    .map((job) => enrichJob(job, { maxProgressLines }));
+
+  const latestFinishedRaw = jobs.find((job) => job.status !== "queued" && job.status !== "running") ?? null;
+  const latestFinished = latestFinishedRaw ? enrichJob(latestFinishedRaw, { maxProgressLines }) : null;
+
+  const recent = (options.all ? jobs : jobs.slice(0, maxJobs))
+    .filter((job) => job.status !== "queued" && job.status !== "running" && job.id !== latestFinished?.id)
+    .map((job) => enrichJob(job, { maxProgressLines }));
+
+  return {
+    workspaceRoot,
+    running,
+    latestFinished,
+    recent
+  };
+}
+
+export function buildSingleJobSnapshot(cwd, reference, options = {}) {
+  const workspaceRoot = resolveWorkspaceRoot(cwd);
+  const jobs = sortJobsNewestFirst(listJobs(workspaceRoot));
+  const selected = matchJobReference(jobs, reference);
+  if (!selected) {
+    throw new Error(`No job found for "${reference}". Run /dsh:status to inspect known jobs.`);
+  }
+
+  return {
+    workspaceRoot,
+    job: enrichJob(selected, { maxProgressLines: options.maxProgressLines })
+  };
+}
+
+export function resolveResultJob(cwd, reference) {
+  const workspaceRoot = resolveWorkspaceRoot(cwd);
+  const jobs = sortJobsNewestFirst(reference ? listJobs(workspaceRoot) : filterJobsForCurrentSession(listJobs(workspaceRoot)));
+  const selected = matchJobReference(
+    jobs,
+    reference,
+    (job) => job.status === "completed" || job.status === "failed" || job.status === "cancelled"
+  );
+
+  if (selected) {
+    return { workspaceRoot, job: selected };
+  }
+
+  const active = matchJobReference(jobs, reference, (job) => job.status === "queued" || job.status === "running");
+  if (active) {
+    throw new Error(`Job ${active.id} is still ${active.status}. Check /dsh:status and try again once it finishes.`);
+  }
+
+  if (reference) {
+    throw new Error(`No finished job found for "${reference}". Run /dsh:status to inspect active jobs.`);
+  }
+
+  throw new Error("No finished dsh jobs found for this repository yet.");
+}
+
+export function resolveCancelableJob(cwd, reference, options = {}) {
+  const workspaceRoot = resolveWorkspaceRoot(cwd);
+  reconcileStaleJobs(workspaceRoot);
+  const jobs = sortJobsNewestFirst(listJobs(workspaceRoot));
+  const activeJobs = jobs.filter((job) => job.status === "queued" || job.status === "running");
+
+  if (reference) {
+    const selected = matchJobReference(activeJobs, reference);
+    if (!selected) {
+      throw new Error(`No active job found for "${reference}".`);
+    }
+    return { workspaceRoot, job: selected };
+  }
+
+  const sessionScopedActiveJobs = filterJobsForCurrentSession(activeJobs, options);
+
+  if (sessionScopedActiveJobs.length === 1) {
+    return { workspaceRoot, job: sessionScopedActiveJobs[0] };
+  }
+  if (sessionScopedActiveJobs.length > 1) {
+    throw new Error("Multiple dsh jobs are active. Pass a job id to /dsh:cancel.");
+  }
+
+  if (getCurrentSessionId(options)) {
+    throw new Error("No active dsh jobs to cancel for this session.");
+  }
+
+  throw new Error("No active dsh jobs to cancel.");
+}
+
+function isActiveStatus(status) {
+  return status === "queued" || status === "running";
+}
+
+/**
+ * Finds the rescue job a resume should continue. Shared by `task --resume-last` and
+ * `task-resume-candidate` so the picker and the executor can never disagree.
+ * Only jobs of this Claude session and this cwd count, because dsh refuses to adopt a session
+ * recorded under another cwd. Returns null when there is no candidate.
+ */
+export function resolveResumableTask(cwd, options = {}) {
+  const workspaceRoot = resolveWorkspaceRoot(cwd);
+  const sessionId = getCurrentSessionId(options);
+  if (!sessionId) {
+    // Without a Claude session id every session would see every other session's rescue jobs.
+    return null;
+  }
+  reconcileStaleJobs(workspaceRoot);
+  const jobs = sortJobsNewestFirst(listJobs(workspaceRoot)).filter(
+    (job) =>
+      job.kind === "task" && job.id !== options.excludeJobId && job.sessionId === sessionId && job.cwd === cwd
+  );
+
+  const running = jobs.find((job) => isActiveStatus(job.status));
+  if (running) {
+    throw new Error(`Task ${running.id} is still running.`);
+  }
+  // The newest rescue run is the one the user means. If it never got a dsh session, there is nothing
+  // to resume; an older session must not be continued in its place.
+  const newest = jobs[0];
+  return newest?.dshSessionId ? newest : null;
+}

package/plugins/dsh/scripts/lib/plans.mjs

@@ -0,0 +1,70 @@
+import fs from "node:fs";
+import path from "node:path";
+
+const SKIPPED_DIRS = new Set(["reports", "archive"]);
+
+// Symlinks are skipped: a plan folder must not be able to pull in files from elsewhere on disk.
+function isPlainFile(file) {
+  try {
+    return fs.lstatSync(file).isFile();
+  } catch {
+    return false;
+  }
+}
+
+function listPhaseFiles(dir) {
+  return fs
+    .readdirSync(dir)
+    .filter((name) => /^phase-.*\.md$/.test(name) && isPlainFile(path.join(dir, name)))
+    .sort();
+}
+
+function newestMtimeMs(dir) {
+  const names = ["plan.md", ...listPhaseFiles(dir)];
+  return Math.max(...names.map((name) => fs.statSync(path.join(dir, name)).mtimeMs));
+}
+
+/**
+ * Returns the plan directory under `<root>/plans/` that changed most recently, relative to `root`,
+ * or null. A plan directory contains `plan.md`. `reports/` and `archive/` are skipped.
+ */
+export function findLatestPlanDir(root) {
+  const plansDir = path.join(root, "plans");
+  if (!fs.existsSync(plansDir)) {
+    return null;
+  }
+
+  let latest = null;
+  for (const entry of fs.readdirSync(plansDir, { withFileTypes: true })) {
+    if (!entry.isDirectory() || SKIPPED_DIRS.has(entry.name)) {
+      continue;
+    }
+    const dir = path.join(plansDir, entry.name);
+    if (!isPlainFile(path.join(dir, "plan.md"))) {
+      continue;
+    }
+    const mtime = newestMtimeMs(dir);
+    if (!latest || mtime > latest.mtime) {
+      latest = { name: entry.name, mtime };
+    }
+  }
+  return latest ? path.join("plans", latest.name) : null;
+}
+
+/**
+ * Resolves a plan path to the files to review. A file yields itself. A directory yields `plan.md`
+ * followed by every `phase-*.md` in name order. Throws when the path or `plan.md` is missing.
+ */
+export function collectPlanFiles(absolutePath) {
+  if (!fs.existsSync(absolutePath)) {
+    throw new Error(`Plan path not found: ${absolutePath}`);
+  }
+  if (!fs.statSync(absolutePath).isDirectory()) {
+    return [absolutePath];
+  }
+  const planFile = path.join(absolutePath, "plan.md");
+  if (!isPlainFile(planFile)) {
+    throw new Error(`No plan.md in ${absolutePath}. Pass a plan file or a directory that has plan.md.`);
+  }
+  return [planFile, ...listPhaseFiles(absolutePath).map((name) => path.join(absolutePath, name))];
+}

package/plugins/dsh/scripts/lib/process.mjs

@@ -0,0 +1,156 @@
+import { spawnSync } from "node:child_process";
+import process from "node:process";
+
+export function runCommand(command, args = [], options = {}) {
+  const result = spawnSync(command, args, {
+    cwd: options.cwd,
+    env: options.env,
+    encoding: "utf8",
+    input: options.input,
+    maxBuffer: options.maxBuffer,
+    stdio: options.stdio ?? "pipe",
+    shell: options.shell ?? (process.platform === "win32" ? (process.env.SHELL || true) : false),
+    windowsHide: true
+  });
+
+  return {
+    command,
+    args,
+    status: result.status ?? 0,
+    signal: result.signal ?? null,
+    stdout: result.stdout ?? "",
+    stderr: result.stderr ?? "",
+    error: result.error ?? null
+  };
+}
+
+export function runCommandChecked(command, args = [], options = {}) {
+  const result = runCommand(command, args, options);
+  if (result.error) {
+    throw result.error;
+  }
+  if (result.status !== 0) {
+    throw new Error(formatCommandFailure(result));
+  }
+  return result;
+}
+
+export function binaryAvailable(command, versionArgs = ["--version"], options = {}) {
+  const result = runCommand(command, versionArgs, options);
+  if (result.error && /** @type {NodeJS.ErrnoException} */ (result.error).code === "ENOENT") {
+    return { available: false, detail: "not found" };
+  }
+  if (result.error) {
+    return { available: false, detail: result.error.message };
+  }
+  if (result.status !== 0) {
+    const detail = result.stderr.trim() || result.stdout.trim() || `exit ${result.status}`;
+    return { available: false, detail };
+  }
+  return { available: true, detail: result.stdout.trim() || result.stderr.trim() || "ok" };
+}
+
+function looksLikeMissingProcessMessage(text) {
+  return /not found|no running instance|cannot find|does not exist|no such process/i.test(text);
+}
+
+export function terminateProcessTree(pid, options = {}) {
+  if (!Number.isFinite(pid)) {
+    return { attempted: false, delivered: false, method: null };
+  }
+
+  const platform = options.platform ?? process.platform;
+  const runCommandImpl = options.runCommandImpl ?? runCommand;
+  const killImpl = options.killImpl ?? process.kill.bind(process);
+
+  if (platform === "win32") {
+    const result = runCommandImpl("taskkill", ["/PID", String(pid), "/T", "/F"], {
+      cwd: options.cwd,
+      env: options.env
+    });
+
+    if (!result.error && result.status === 0) {
+      return { attempted: true, delivered: true, method: "taskkill", result };
+    }
+
+    const combinedOutput = `${result.stderr}\n${result.stdout}`.trim();
+    if (!result.error && looksLikeMissingProcessMessage(combinedOutput)) {
+      return { attempted: true, delivered: false, method: "taskkill", result };
+    }
+
+    if (result.error?.code === "ENOENT") {
+      try {
+        killImpl(pid);
+        return { attempted: true, delivered: true, method: "kill" };
+      } catch (error) {
+        if (error?.code === "ESRCH") {
+          return { attempted: true, delivered: false, method: "kill" };
+        }
+        throw error;
+      }
+    }
+
+    if (result.error) {
+      throw result.error;
+    }
+
+    throw new Error(formatCommandFailure(result));
+  }
+
+  try {
+    killImpl(-pid, "SIGTERM");
+    return { attempted: true, delivered: true, method: "process-group" };
+  } catch (error) {
+    if (error?.code !== "ESRCH") {
+      try {
+        killImpl(pid, "SIGTERM");
+        return { attempted: true, delivered: true, method: "process" };
+      } catch (innerError) {
+        if (innerError?.code === "ESRCH") {
+          return { attempted: true, delivered: false, method: "process" };
+        }
+        throw innerError;
+      }
+    }
+
+    return { attempted: true, delivered: false, method: "process-group" };
+  }
+}
+
+export function formatCommandFailure(result) {
+  const parts = [`${result.command} ${result.args.join(" ")}`.trim()];
+  if (result.signal) {
+    parts.push(`signal=${result.signal}`);
+  } else {
+    parts.push(`exit=${result.status}`);
+  }
+  const stderr = (result.stderr || "").trim();
+  const stdout = (result.stdout || "").trim();
+  if (stderr) {
+    parts.push(stderr);
+  } else if (stdout) {
+    parts.push(stdout);
+  }
+  return parts.join(": ");
+}
+
+export function isProcessAlive(pid) {
+  if (!Number.isFinite(pid)) {
+    return false;
+  }
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error?.code === "EPERM";
+  }
+}
+
+// Used before signalling a recorded pid, so a reused pid of an unrelated process is never killed.
+export function processCommandIncludes(pid, needle) {
+  if (!Number.isFinite(pid) || process.platform === "win32") {
+    return isProcessAlive(pid);
+  }
+  const result = runCommand("ps", ["-o", "command=", "-p", String(pid)], { shell: false });
+  return result.status === 0 && result.stdout.includes(needle);
+}

package/plugins/dsh/scripts/lib/prompts.mjs

@@ -0,0 +1,13 @@
+import fs from "node:fs";
+import path from "node:path";
+
+export function loadPromptTemplate(rootDir, name) {
+  const promptPath = path.join(rootDir, "prompts", `${name}.md`);
+  return fs.readFileSync(promptPath, "utf8");
+}
+
+export function interpolateTemplate(template, variables) {
+  return template.replace(/\{\{([A-Z_]+)\}\}/g, (_, key) => {
+    return Object.prototype.hasOwnProperty.call(variables, key) ? variables[key] : "";
+  });
+}