@calltelemetry/openclaw-linear 0.9.3 → 0.9.4

package/src/infra/multi-repo.test.ts

@@ -1,4 +1,6 @@
 import { describe, it, expect, vi, beforeEach } from "vitest";
+import { homedir } from "node:os";
+import path from "node:path";
 import { resolveRepos, isMultiRepo, validateRepoPath, type RepoResolution } from "./multi-repo.ts";
 
 vi.mock("node:fs", async (importOriginal) => {
@@ -46,12 +48,12 @@ describe("resolveRepos", () => {
   });
 
   it("falls back to config repos when no markers/labels", () => {
-    const config = { codexBaseRepo: "/home/claw/myproject" };
+    const config = { codexBaseRepo: "/tmp/test/myproject" };
     const result = resolveRepos("Plain description", [], config);
     expect(result.source).toBe("config_default");
     expect(result.repos).toHaveLength(1);
     expect(result.repos[0].name).toBe("default");
-    expect(result.repos[0].path).toBe("/home/claw/myproject");
+    expect(result.repos[0].path).toBe("/tmp/test/myproject");
   });
 
   it("body markers take priority over labels", () => {
@@ -69,7 +71,7 @@ describe("resolveRepos", () => {
     expect(result.source).toBe("config_default");
     expect(result.repos).toHaveLength(1);
     expect(result.repos[0].name).toBe("default");
-    expect(result.repos[0].path).toBe("/home/claw/ai-workspace");
+    expect(result.repos[0].path).toBe(path.join(homedir(), "ai-workspace"));
   });
 
   it("handles empty description + no labels (single repo fallback)", () => {
@@ -104,8 +106,8 @@ describe("isMultiRepo", () => {
   it("returns true for 2+ repos", () => {
     const resolution: RepoResolution = {
       repos: [
-        { name: "api", path: "/home/claw/api" },
-        { name: "frontend", path: "/home/claw/frontend" },
+        { name: "api", path: "/tmp/test/api" },
+        { name: "frontend", path: "/tmp/test/frontend" },
       ],
       source: "issue_body",
     };
@@ -114,7 +116,7 @@ describe("isMultiRepo", () => {
 
   it("returns false for 1 repo", () => {
     const resolution: RepoResolution = {
-      repos: [{ name: "default", path: "/home/claw/ai-workspace" }],
+      repos: [{ name: "default", path: "/tmp/test/ai-workspace" }],
       source: "config_default",
     };
     expect(isMultiRepo(resolution)).toBe(false);
@@ -143,21 +145,21 @@ describe("validateRepoPath", () => {
   it("returns isGitRepo:true, isSubmodule:false for normal repo (.git is directory)", () => {
     mockExistsSync.mockReturnValue(true);
     mockStatSync.mockReturnValue({ isFile: () => false, isDirectory: () => true });
-    const result = validateRepoPath("/home/claw/repos/api");
+    const result = validateRepoPath("/tmp/test/repos/api");
     expect(result).toEqual({ exists: true, isGitRepo: true, isSubmodule: false });
   });
 
   it("returns isGitRepo:true, isSubmodule:true for submodule (.git is file)", () => {
     mockExistsSync.mockReturnValue(true);
     mockStatSync.mockReturnValue({ isFile: () => true, isDirectory: () => false });
-    const result = validateRepoPath("/home/claw/workspace/submod");
+    const result = validateRepoPath("/tmp/test/workspace/submod");
     expect(result).toEqual({ exists: true, isGitRepo: true, isSubmodule: true });
   });
 
   it("returns isGitRepo:false for directory without .git", () => {
     // First call: path exists. Second call: .git does not exist
     mockExistsSync.mockImplementation((p: string) => !String(p).endsWith(".git"));
-    const result = validateRepoPath("/home/claw/not-a-repo");
+    const result = validateRepoPath("/tmp/test/not-a-repo");
     expect(result).toEqual({ exists: true, isGitRepo: false, isSubmodule: false });
   });
 });

package/src/infra/multi-repo.ts

@@ -8,6 +8,7 @@
  */
 
 import { existsSync, statSync } from "node:fs";
+import { homedir } from "node:os";
 import path from "node:path";
 
 export interface RepoConfig {
@@ -62,7 +63,7 @@ export function resolveRepos(
   }
 
   // 3. Config default: single repo
-  const baseRepo = (pluginConfig?.codexBaseRepo as string) ?? "/home/claw/ai-workspace";
+  const baseRepo = (pluginConfig?.codexBaseRepo as string) ?? path.join(homedir(), "ai-workspace");
   return {
     repos: [{ name: "default", path: baseRepo }],
     source: "config_default",
@@ -76,7 +77,7 @@ function getRepoMap(pluginConfig?: Record<string, unknown>): Record<string, stri
 
 function resolveRepoPath(name: string, pluginConfig?: Record<string, unknown>): string {
   // Convention: {parentDir}/{name}
-  const baseRepo = (pluginConfig?.codexBaseRepo as string) ?? "/home/claw/ai-workspace";
+  const baseRepo = (pluginConfig?.codexBaseRepo as string) ?? path.join(homedir(), "ai-workspace");
   const parentDir = path.dirname(baseRepo);
   return path.join(parentDir, name);
 }

package/src/infra/shared-profiles.ts

@@ -7,6 +7,7 @@
  */
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
+import { homedir } from "node:os";
 
 // ---------------------------------------------------------------------------
 // Types
@@ -25,7 +26,7 @@ export interface AgentProfile {
 // Cached profile loader (5s TTL)
 // ---------------------------------------------------------------------------
 
-const PROFILES_PATH = join(process.env.HOME ?? "/home/claw", ".openclaw", "agent-profiles.json");
+const PROFILES_PATH = join(homedir(), ".openclaw", "agent-profiles.json");
 
 let profilesCache: { data: Record<string, AgentProfile>; loadedAt: number } | null = null;
 const PROFILES_CACHE_TTL_MS = 5_000;

package/src/infra/template.test.ts

@@ -62,9 +62,9 @@ describe("renderTemplate", () => {
     const result = renderTemplate(template, {
       identifier: "CT-42",
       title: "Implement auth",
-      worktreePath: "/home/claw/worktrees/ct-42",
+      worktreePath: "/tmp/test/worktrees/ct-42",
     });
-    expect(result).toBe("Issue: CT-42\nTitle: Implement auth\nWorktree: /home/claw/worktrees/ct-42");
+    expect(result).toBe("Issue: CT-42\nTitle: Implement auth\nWorktree: /tmp/test/worktrees/ct-42");
   });
 
   it("handles special regex characters in values", () => {

package/src/pipeline/active-session.test.ts

@@ -10,6 +10,11 @@ import {
   getCurrentSession,
   getSessionCount,
   hydrateFromDispatchState,
+  recordIssueAffinity,
+  getIssueAffinity,
+  _configureAffinityTtl,
+  _getAffinityTtlMs,
+  _resetAffinityForTesting,
   type ActiveSession,
 } from "./active-session.js";
 
@@ -25,10 +30,11 @@ function makeSession(overrides?: Partial<ActiveSession>): ActiveSession {
 
 // Clean up after each test to avoid cross-contamination
 afterEach(() => {
-  // Clear all known sessions
+  // Clear all known sessions (use sessions.delete directly to avoid triggering affinity)
   clearActiveSession("uuid-1");
   clearActiveSession("uuid-2");
   clearActiveSession("uuid-3");
+  _resetAffinityForTesting();
 });
 
 describe("set + get", () => {
@@ -152,3 +158,92 @@ describe("hydrateFromDispatchState", () => {
     expect(restored).toBe(0);
   });
 });
+
+// ---------------------------------------------------------------------------
+// Issue-agent affinity
+// ---------------------------------------------------------------------------
+
+describe("issue agent affinity", () => {
+  it("recordIssueAffinity + getIssueAffinity round-trip", () => {
+    recordIssueAffinity("uuid-1", "mal");
+    expect(getIssueAffinity("uuid-1")).toBe("mal");
+  });
+
+  it("returns null for unknown issue", () => {
+    expect(getIssueAffinity("no-such-id")).toBeNull();
+  });
+
+  it("returns null after TTL expires", () => {
+    _configureAffinityTtl(100); // 100ms TTL
+    recordIssueAffinity("uuid-1", "mal");
+    vi.useFakeTimers();
+    vi.advanceTimersByTime(150);
+    expect(getIssueAffinity("uuid-1")).toBeNull();
+    vi.useRealTimers();
+  });
+
+  it("returns agent within TTL", () => {
+    _configureAffinityTtl(60_000);
+    recordIssueAffinity("uuid-1", "kaylee");
+    expect(getIssueAffinity("uuid-1")).toBe("kaylee");
+  });
+
+  it("overwrites previous affinity for same issue", () => {
+    recordIssueAffinity("uuid-1", "mal");
+    recordIssueAffinity("uuid-1", "kaylee");
+    expect(getIssueAffinity("uuid-1")).toBe("kaylee");
+  });
+
+  it("tracks separate issues independently", () => {
+    recordIssueAffinity("uuid-1", "mal");
+    recordIssueAffinity("uuid-2", "kaylee");
+    expect(getIssueAffinity("uuid-1")).toBe("mal");
+    expect(getIssueAffinity("uuid-2")).toBe("kaylee");
+  });
+
+  it("clearActiveSession records affinity when agentId present", () => {
+    setActiveSession({
+      agentSessionId: "sess-1",
+      issueIdentifier: "API-100",
+      issueId: "uuid-1",
+      agentId: "mal",
+      startedAt: Date.now(),
+    });
+    clearActiveSession("uuid-1");
+    expect(getActiveSession("uuid-1")).toBeNull(); // session cleared
+    expect(getIssueAffinity("uuid-1")).toBe("mal"); // affinity preserved
+  });
+
+  it("clearActiveSession does NOT record affinity when agentId missing", () => {
+    setActiveSession({
+      agentSessionId: "sess-1",
+      issueIdentifier: "API-100",
+      issueId: "uuid-1",
+      startedAt: Date.now(),
+      // no agentId
+    });
+    clearActiveSession("uuid-1");
+    expect(getIssueAffinity("uuid-1")).toBeNull();
+  });
+
+  it("_resetAffinityForTesting clears all entries and resets TTL", () => {
+    _configureAffinityTtl(5000);
+    recordIssueAffinity("uuid-1", "mal");
+    recordIssueAffinity("uuid-2", "kaylee");
+    _resetAffinityForTesting();
+    expect(getIssueAffinity("uuid-1")).toBeNull();
+    expect(getIssueAffinity("uuid-2")).toBeNull();
+    expect(_getAffinityTtlMs()).toBe(30 * 60_000);
+  });
+
+  it("_configureAffinityTtl sets custom TTL", () => {
+    _configureAffinityTtl(5000);
+    expect(_getAffinityTtlMs()).toBe(5000);
+  });
+
+  it("_configureAffinityTtl resets to default when called with undefined", () => {
+    _configureAffinityTtl(5000);
+    _configureAffinityTtl(undefined);
+    expect(_getAffinityTtlMs()).toBe(30 * 60_000);
+  });
+});

package/src/pipeline/active-session.ts

@@ -26,6 +26,19 @@ export interface ActiveSession {
 // Keyed by issue ID — one active session per issue at a time.
 const sessions = new Map<string, ActiveSession>();
 
+// ---------------------------------------------------------------------------
+// Issue-agent affinity: tracks which agent last handled each issue.
+// Entries expire after a configurable TTL (default 30 min).
+// ---------------------------------------------------------------------------
+
+interface AffinityEntry {
+  agentId: string;
+  recordedAt: number;
+}
+
+const issueAgentAffinity = new Map<string, AffinityEntry>();
+let _affinityTtlMs = 30 * 60_000; // 30 minutes default
+
 /**
  * Register the active session for an issue. Idempotent — calling again
  * for the same issue just updates the session.
@@ -36,8 +49,13 @@ export function setActiveSession(session: ActiveSession): void {
 
 /**
  * Clear the active session for an issue.
+ * If the session had an agentId, records it as affinity for future routing.
  */
 export function clearActiveSession(issueId: string): void {
+  const session = sessions.get(issueId);
+  if (session?.agentId) {
+    recordIssueAffinity(issueId, session.agentId);
+  }
   sessions.delete(issueId);
 }
 
@@ -104,3 +122,45 @@ export async function hydrateFromDispatchState(configPath?: string): Promise<num
 export function getSessionCount(): number {
   return sessions.size;
 }
+
+// ---------------------------------------------------------------------------
+// Issue-agent affinity — public API
+// ---------------------------------------------------------------------------
+
+/**
+ * Record which agent last handled an issue.
+ * Called automatically from clearActiveSession when an agentId is present.
+ */
+export function recordIssueAffinity(issueId: string, agentId: string): void {
+  issueAgentAffinity.set(issueId, { agentId, recordedAt: Date.now() });
+}
+
+/**
+ * Look up which agent last handled an issue.
+ * Returns null if no affinity recorded or if the entry has expired.
+ */
+export function getIssueAffinity(issueId: string): string | null {
+  const entry = issueAgentAffinity.get(issueId);
+  if (!entry) return null;
+  if (Date.now() - entry.recordedAt > _affinityTtlMs) {
+    issueAgentAffinity.delete(issueId);
+    return null;
+  }
+  return entry.agentId;
+}
+
+/** @internal — configure affinity TTL from pluginConfig. */
+export function _configureAffinityTtl(ttlMs?: number): void {
+  _affinityTtlMs = ttlMs ?? 30 * 60_000;
+}
+
+/** @internal — read current affinity TTL (for testing). */
+export function _getAffinityTtlMs(): number {
+  return _affinityTtlMs;
+}
+
+/** @internal — test-only; clears all affinity state and resets TTL. */
+export function _resetAffinityForTesting(): void {
+  issueAgentAffinity.clear();
+  _affinityTtlMs = 30 * 60_000;
+}

package/src/pipeline/artifacts.ts

@@ -293,7 +293,7 @@ export function resolveOrchestratorWorkspace(
   api: any,
   pluginConfig?: Record<string, unknown>,
 ): string {
-  const home = process.env.HOME ?? "/home/claw";
+  const home = homedir();
   const agentId = (pluginConfig?.defaultAgentId as string) ?? "default";
 
   try {

package/src/pipeline/pipeline.test.ts

@@ -14,6 +14,9 @@ vi.mock("./dispatch-state.js", () => ({
 vi.mock("./active-session.js", () => ({
   setActiveSession: vi.fn(),
   clearActiveSession: vi.fn(),
+  getIssueAffinity: vi.fn().mockReturnValue(null),
+  _configureAffinityTtl: vi.fn(),
+  _resetAffinityForTesting: vi.fn(),
 }));
 vi.mock("../infra/notify.js", () => ({}));
 vi.mock("./artifacts.js", () => ({

package/src/pipeline/webhook-dedup.test.ts

@@ -39,6 +39,9 @@ vi.mock("../api/linear-api.js", () => ({
 vi.mock("./active-session.js", () => ({
   setActiveSession: vi.fn(),
   clearActiveSession: vi.fn(),
+  getIssueAffinity: vi.fn().mockReturnValue(null),
+  _configureAffinityTtl: vi.fn(),
+  _resetAffinityForTesting: vi.fn(),
 }));
 
 vi.mock("../infra/observability.js", () => ({