@calltelemetry/openclaw-linear 0.6.0 → 0.7.0

package/src/pipeline/planning-state.ts

@@ -0,0 +1,216 @@
+/**
+ * planning-state.ts — File-backed persistent planning session state.
+ *
+ * Tracks active planning sessions across gateway restarts.
+ * Uses file-level locking to prevent concurrent read-modify-write races.
+ * Mirrors the dispatch-state.ts pattern.
+ */
+import fs from "node:fs/promises";
+import { existsSync, mkdirSync } from "node:fs";
+import path from "node:path";
+import { homedir } from "node:os";
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export type PlanningStatus = "interviewing" | "plan_review" | "approved" | "abandoned";
+
+export interface PlanningSession {
+  projectId: string;
+  projectName: string;
+  rootIssueId: string;
+  rootIdentifier: string;
+  teamId: string;
+  agentSessionId?: string;
+  status: PlanningStatus;
+  startedAt: string;
+  turnCount: number;
+  planningLabelId?: string;
+}
+
+export interface PlanningState {
+  sessions: Record<string, PlanningSession>; // keyed by projectId
+  processedEvents: string[];
+}
+
+// ---------------------------------------------------------------------------
+// Defaults
+// ---------------------------------------------------------------------------
+
+const DEFAULT_STATE_PATH = path.join(homedir(), ".openclaw", "linear-planning-state.json");
+const MAX_PROCESSED_EVENTS = 200;
+
+function resolveStatePath(configPath?: string): string {
+  if (!configPath) return DEFAULT_STATE_PATH;
+  if (configPath.startsWith("~/")) return configPath.replace("~", homedir());
+  return configPath;
+}
+
+// ---------------------------------------------------------------------------
+// File locking
+// ---------------------------------------------------------------------------
+
+const LOCK_STALE_MS = 30_000;
+const LOCK_RETRY_MS = 50;
+const LOCK_TIMEOUT_MS = 10_000;
+
+function lockPath(statePath: string): string {
+  return statePath + ".lock";
+}
+
+async function acquireLock(statePath: string): Promise<void> {
+  const lock = lockPath(statePath);
+  const deadline = Date.now() + LOCK_TIMEOUT_MS;
+
+  while (Date.now() < deadline) {
+    try {
+      await fs.writeFile(lock, String(Date.now()), { flag: "wx" });
+      return;
+    } catch (err: any) {
+      if (err.code !== "EEXIST") throw err;
+
+      try {
+        const content = await fs.readFile(lock, "utf-8");
+        const lockTime = Number(content);
+        if (Date.now() - lockTime > LOCK_STALE_MS) {
+          try { await fs.unlink(lock); } catch { /* race */ }
+          continue;
+        }
+      } catch { /* lock disappeared — retry */ }
+
+      await new Promise((r) => setTimeout(r, LOCK_RETRY_MS));
+    }
+  }
+
+  try { await fs.unlink(lockPath(statePath)); } catch { /* ignore */ }
+  await fs.writeFile(lock, String(Date.now()), { flag: "wx" });
+}
+
+async function releaseLock(statePath: string): Promise<void> {
+  try { await fs.unlink(lockPath(statePath)); } catch { /* already removed */ }
+}
+
+// ---------------------------------------------------------------------------
+// Read / Write
+// ---------------------------------------------------------------------------
+
+function emptyState(): PlanningState {
+  return { sessions: {}, processedEvents: [] };
+}
+
+export async function readPlanningState(configPath?: string): Promise<PlanningState> {
+  const filePath = resolveStatePath(configPath);
+  try {
+    const raw = await fs.readFile(filePath, "utf-8");
+    const parsed = JSON.parse(raw) as PlanningState;
+    if (!parsed.sessions) parsed.sessions = {};
+    if (!parsed.processedEvents) parsed.processedEvents = [];
+    return parsed;
+  } catch (err: any) {
+    if (err.code === "ENOENT") return emptyState();
+    throw err;
+  }
+}
+
+export async function writePlanningState(data: PlanningState, configPath?: string): Promise<void> {
+  const filePath = resolveStatePath(configPath);
+  const dir = path.dirname(filePath);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  if (data.processedEvents.length > MAX_PROCESSED_EVENTS) {
+    data.processedEvents = data.processedEvents.slice(-MAX_PROCESSED_EVENTS);
+  }
+  const tmpPath = filePath + ".tmp";
+  await fs.writeFile(tmpPath, JSON.stringify(data, null, 2) + "\n", "utf-8");
+  await fs.rename(tmpPath, filePath);
+}
+
+// ---------------------------------------------------------------------------
+// Session operations
+// ---------------------------------------------------------------------------
+
+export async function registerPlanningSession(
+  projectId: string,
+  session: PlanningSession,
+  configPath?: string,
+): Promise<void> {
+  const filePath = resolveStatePath(configPath);
+  await acquireLock(filePath);
+  try {
+    const data = await readPlanningState(configPath);
+    data.sessions[projectId] = session;
+    await writePlanningState(data, configPath);
+  } finally {
+    await releaseLock(filePath);
+  }
+}
+
+export async function updatePlanningSession(
+  projectId: string,
+  updates: Partial<PlanningSession>,
+  configPath?: string,
+): Promise<PlanningSession> {
+  const filePath = resolveStatePath(configPath);
+  await acquireLock(filePath);
+  try {
+    const data = await readPlanningState(configPath);
+    const session = data.sessions[projectId];
+    if (!session) throw new Error(`No planning session for project ${projectId}`);
+    Object.assign(session, updates);
+    await writePlanningState(data, configPath);
+    return session;
+  } finally {
+    await releaseLock(filePath);
+  }
+}
+
+export function getPlanningSession(
+  state: PlanningState,
+  projectId: string,
+): PlanningSession | null {
+  return state.sessions[projectId] ?? null;
+}
+
+export async function endPlanningSession(
+  projectId: string,
+  status: "approved" | "abandoned",
+  configPath?: string,
+): Promise<void> {
+  const filePath = resolveStatePath(configPath);
+  await acquireLock(filePath);
+  try {
+    const data = await readPlanningState(configPath);
+    const session = data.sessions[projectId];
+    if (session) {
+      session.status = status;
+      await writePlanningState(data, configPath);
+    }
+    clearPlanningCache(projectId);
+  } finally {
+    await releaseLock(filePath);
+  }
+}
+
+export function isInPlanningMode(state: PlanningState, projectId: string): boolean {
+  const session = state.sessions[projectId];
+  if (!session) return false;
+  return session.status === "interviewing" || session.status === "plan_review";
+}
+
+// ---------------------------------------------------------------------------
+// In-memory cache for fast webhook routing
+// ---------------------------------------------------------------------------
+
+const planningCache = new Map<string, PlanningSession>();
+
+export function setPlanningCache(session: PlanningSession): void {
+  planningCache.set(session.projectId, session);
+}
+
+export function clearPlanningCache(projectId: string): void {
+  planningCache.delete(projectId);
+}
+
+export function getActivePlanningByProjectId(projectId: string): PlanningSession | null {
+  return planningCache.get(projectId) ?? null;
+}

package/src/pipeline/webhook.ts

@@ -6,10 +6,12 @@ import { LinearAgentApi, resolveLinearToken } from "../api/linear-api.js";
 import { spawnWorker, type HookContext } from "./pipeline.js";
 import { setActiveSession, clearActiveSession } from "./active-session.js";
 import { readDispatchState, getActiveDispatch, registerDispatch, updateDispatchStatus, completeDispatch, removeActiveDispatch } from "./dispatch-state.js";
-import { createDiscordNotifier, createNoopNotifier, type NotifyFn } from "../infra/notify.js";
+import { createNotifierFromConfig, type NotifyFn } from "../infra/notify.js";
 import { assessTier } from "./tier-assess.js";
 import { createWorktree, prepareWorkspace } from "../infra/codex-worktree.js";
 import { ensureClawDir, writeManifest } from "./artifacts.js";
+import { readPlanningState, isInPlanningMode, getPlanningSession } from "./planning-state.js";
+import { initiatePlanningSession, handlePlannerTurn } from "./planner.js";
 
 // ── Agent profiles (loaded from config, no hardcoded names) ───────
 interface AgentProfile {
@@ -663,6 +665,50 @@ export async function handleLinearWebhook(
     const commentor = comment?.user?.name ?? "Unknown";
     const issue = comment?.issue ?? payload.issue;
 
+    // ── Planning mode intercept ──────────────────────────────────
+    if (issue?.id) {
+      const linearApiForPlanning = createLinearApi(api);
+      if (linearApiForPlanning) {
+        try {
+          const enriched = await linearApiForPlanning.getIssueDetails(issue.id);
+          const projectId = enriched?.project?.id;
+          const planStatePath = pluginConfig?.planningStatePath as string | undefined;
+
+          if (projectId) {
+            const planState = await readPlanningState(planStatePath);
+
+            // Check if this is a plan initiation request
+            const isPlanRequest = /\b(plan|planning)\s+(this\s+)?(project|out)\b/i.test(commentBody);
+            if (isPlanRequest && !isInPlanningMode(planState, projectId)) {
+              api.logger.info(`Planning: initiation requested on ${issue.identifier ?? issue.id}`);
+              void initiatePlanningSession(
+                { api, linearApi: linearApiForPlanning, pluginConfig },
+                projectId,
+                { id: issue.id, identifier: enriched.identifier, title: enriched.title, team: enriched.team },
+              ).catch((err) => api.logger.error(`Planning initiation error: ${err}`));
+              return true;
+            }
+
+            // Route to planner if project is in planning mode
+            if (isInPlanningMode(planState, projectId)) {
+              const session = getPlanningSession(planState, projectId);
+              if (session && comment?.id && !wasRecentlyProcessed(`plan-comment:${comment.id}`)) {
+                api.logger.info(`Planning: routing comment to planner for ${session.projectName}`);
+                void handlePlannerTurn(
+                  { api, linearApi: linearApiForPlanning, pluginConfig },
+                  session,
+                  { issueId: issue.id, commentBody, commentorName: commentor },
+                ).catch((err) => api.logger.error(`Planner turn error: ${err}`));
+              }
+              return true;
+            }
+          }
+        } catch (err) {
+          api.logger.warn(`Planning mode check failed: ${err}`);
+        }
+      }
+    }
+
     // Load agent profiles and build mention pattern dynamically.
     // Default agent (app mentions) is handled by AgentSessionEvent — never here.
     const profiles = loadAgentProfiles();
@@ -1161,6 +1207,26 @@ async function handleDispatch(
 
   api.logger.info(`@dispatch: processing ${identifier}`);
 
+  // 0. Check planning mode — prevent dispatch for issues in planning-mode projects
+  try {
+    const enrichedForPlan = await linearApi.getIssueDetails(issue.id ?? issue);
+    const planProjectId = enrichedForPlan?.project?.id;
+    if (planProjectId) {
+      const planStatePath = pluginConfig?.planningStatePath as string | undefined;
+      const planState = await readPlanningState(planStatePath);
+      if (isInPlanningMode(planState, planProjectId)) {
+        api.logger.info(`dispatch: ${identifier} is in planning-mode project — skipping`);
+        await linearApi.createComment(
+          issue.id,
+          "This project is in planning mode. Finalize the plan before dispatching implementation.",
+        );
+        return;
+      }
+    }
+  } catch (err) {
+    api.logger.warn(`dispatch: planning mode check failed for ${identifier}: ${err}`);
+  }
+
   // 1. Check for existing active dispatch — reclaim if stale
   const STALE_DISPATCH_MS = 30 * 60_000; // 30 min without a gateway holding it = stale
   const state = await readDispatchState(statePath);
@@ -1337,22 +1403,8 @@ async function handleDispatch(
   // 11. Run v2 pipeline: worker → audit → verdict (non-blocking)
   activeRuns.add(issue.id);
 
-  // Instantiate notifier
-  const discordBotToken = (() => {
-    try {
-      const config = JSON.parse(
-        require("node:fs").readFileSync(
-          require("node:path").join(process.env.HOME ?? "/home/claw", ".openclaw", "openclaw.json"),
-          "utf8",
-        ),
-      );
-      return config?.channels?.discord?.token as string | undefined;
-    } catch { return undefined; }
-  })();
-  const flowDiscordChannel = pluginConfig?.flowDiscordChannel as string | undefined;
-  const notify: NotifyFn = (discordBotToken && flowDiscordChannel)
-    ? createDiscordNotifier(discordBotToken, flowDiscordChannel)
-    : createNoopNotifier();
+  // Instantiate notifier (Discord, Slack, or both — config-driven)
+  const notify: NotifyFn = createNotifierFromConfig(pluginConfig, api.runtime);
 
   const hookCtx: HookContext = {
     api,