larkway 0.3.28 → 0.3.29

package/README.md

@@ -8,7 +8,7 @@
 
 You @ the bot in a Feishu thread. It runs on your machine — reading your real codebase, executing commands, opening MRs — and posts the result back. You define what the agent knows and what it can do. Larkway just carries the messages.
 
-**Current release: v0.3.28**
+**Current release: v0.3.29**
 
 ---
 

package/README.zh.md

@@ -8,7 +8,7 @@
 
 你在飞书话题里 @ bot，它在你的机器上运行——读真实代码库、执行命令、开 MR——把结果贴回飞书。你定义 agent 知道什么、能做什么。Larkway 只负责传递消息。
 
-**当前版本：v0.3.28**
+**当前版本：v0.3.29**
 
 ---
 

package/dist/main.js

@@ -115875,6 +115875,10 @@ function resolveAgentWorkspacePath(agentId) {
 function resolveAgentWorkspaceSessionsDir(agentId) {
   return join(resolveAgentWorkspacePath(agentId), "sessions");
 }
+function resolveAgentSessionPath(agentId, threadId) {
+  assertSafePathSegment("threadId", threadId);
+  return join(resolveAgentWorkspaceSessionsDir(agentId), threadId);
+}
 function resolveAgentWorkspaceReposDir(agentId) {
   return join(resolveAgentWorkspacePath(agentId), "repos");
 }
@@ -121398,6 +121402,13 @@ var BridgeHandler = class {
             botGitIdentity: this.deps.botConfig?.git_identity,
             gitlabToken: this.deps.gitlabToken
           });
+          if (isAgentWorkspace && handle.pid != null) {
+            const sessionPidFile = path9.join(worktreePath, ".larkway", "runner.pid");
+            void fs6.mkdir(path9.dirname(sessionPidFile), { recursive: true }).then(
+              () => fs6.writeFile(sessionPidFile, JSON.stringify({ pid: handle.pid }), "utf8")
+            ).catch(() => {
+            });
+          }
           let sessionId;
           let trustedAnswerText = "";
           try {
@@ -121793,7 +121804,7 @@ function isRuntimeEventRecord(value) {
 
 // src/housekeeping/gc.ts
 import { spawn } from "node:child_process";
-import { readFile as readFile4, readdir, stat } from "node:fs/promises";
+import { readFile as readFile4, readdir, rm, stat } from "node:fs/promises";
 import { join as pathJoin } from "node:path";
 var DEFAULT_SCAN_INTERVAL_MS = 30 * 60 * 1e3;
 var DEFAULT_IDLE_NOTIFY_MS = 4 * 60 * 60 * 1e3;
@@ -121805,12 +121816,20 @@ var Housekeeping = class {
   #idleCleanupMs;
   /** This housekeeping's bot scope — resolves which worktrees dir to sweep. */
   #botId;
+  /**
+   * Bot runtime. "agent_workspace" reclaims per-thread session dirs under
+   * agents/<id>/workspace/sessions/ via rm -rf (they are plain dirs / full
+   * clones, not git worktrees). Anything else (legacy) reclaims git worktrees
+   * under <botId>/worktrees/ via `git worktree remove`.
+   */
+  #runtime;
   /** thread_ids that have already received an idle-notify warn this session */
   #notified = /* @__PURE__ */ new Set();
   #timer;
   constructor(deps, opts) {
     this.#sessionStore = deps.sessionStore;
     this.#botId = deps.botId;
+    this.#runtime = deps.runtime;
     this.#scanIntervalMs = opts?.scanIntervalMs ?? DEFAULT_SCAN_INTERVAL_MS;
     this.#idleNotifyMs = opts?.idleNotifyMs ?? DEFAULT_IDLE_NOTIFY_MS;
     this.#idleCleanupMs = opts?.idleCleanupMs ?? DEFAULT_IDLE_CLEANUP_MS;
@@ -121855,9 +121874,9 @@ var Housekeeping = class {
       if (idleMs >= this.#idleCleanupMs) {
         const idleHours = Math.floor(idleMs / (60 * 60 * 1e3));
         console.warn(
-          `[housekeeping] \u8BDD\u9898 ${tid} idle ${idleHours}h+,worktree \u53EF\u6E05\u7406`
+          `[housekeeping] \u8BDD\u9898 ${tid} idle ${idleHours}h+,\u5DE5\u4F5C\u76EE\u5F55\u53EF\u6E05\u7406`
         );
-        void cleanupWorktree(tid, record.botId, dryRun);
+        void this.#cleanupThread(tid, record.botId, dryRun);
         this.#notified.delete(tid);
         continue;
       }
@@ -121878,33 +121897,47 @@ var Housekeeping = class {
    * cleanupWorktree (kill PIDs → git worktree remove --force).
    */
   async #sweepOrphans(liveThreadIds, now, dryRun) {
-    const worktreesDir = resolveWorktreesDir(this.#botId);
+    const reclaimDir = this.#runtime === "agent_workspace" ? resolveAgentWorkspaceSessionsDir(this.#botId ?? "") : resolveWorktreesDir(this.#botId);
     let dirNames;
     try {
-      const entries = await readdir(worktreesDir, { withFileTypes: true });
+      const entries = await readdir(reclaimDir, { withFileTypes: true });
       dirNames = entries.filter((e) => e.isDirectory()).map((e) => e.name);
     } catch (err) {
       if (err.code !== "ENOENT") {
-        console.error(`[gc] orphan sweep: cannot read ${worktreesDir}:`, err);
+        console.error(`[gc] orphan sweep: cannot read ${reclaimDir}:`, err);
       }
       return;
     }
     for (const name of selectOrphanWorktreeNames(dirNames, liveThreadIds)) {
-      const wtPath = pathJoin(worktreesDir, name);
+      if (name.startsWith("_")) continue;
+      const dirPath = pathJoin(reclaimDir, name);
       let ageMs;
       try {
-        ageMs = now - (await stat(wtPath)).mtimeMs;
+        ageMs = now - (await stat(dirPath)).mtimeMs;
       } catch {
         continue;
       }
       if (ageMs < this.#idleCleanupMs) continue;
       const ageHours = Math.floor(ageMs / (60 * 60 * 1e3));
       console.warn(
-        `[housekeeping] orphan worktree ${name}(\u65E0 session \u8BB0\u5F55, idle ${ageHours}h+)\u2014 \u6E05\u7406`
+        `[housekeeping] orphan ${name}(\u65E0 session \u8BB0\u5F55, idle ${ageHours}h+)\u2014 \u6E05\u7406`
       );
-      await cleanupWorktree(name, this.#botId, dryRun);
+      await this.#cleanupThread(name, this.#botId, dryRun);
     }
   }
+  /**
+   * Runtime-aware reclaim of one thread's working dir.
+   * - agent_workspace: rm -rf agents/<id>/workspace/sessions/<tid> (plain dir /
+   *   full clones — `git worktree remove` cannot reclaim these).
+   * - legacy:          git worktree remove --force <botId>/worktrees/<tid>.
+   * Both kill any lingering runner PIDs first (idle >24h → normally dead).
+   */
+  #cleanupThread(threadId, botId, dryRun) {
+    if (this.#runtime === "agent_workspace") {
+      return cleanupAgentSession(threadId, botId ?? this.#botId, dryRun);
+    }
+    return cleanupWorktree(threadId, botId, dryRun);
+  }
 };
 function selectOrphanWorktreeNames(dirNames, liveThreadIds) {
   return dirNames.filter((name) => !liveThreadIds.has(name));
@@ -122034,6 +122067,61 @@ async function cleanupWorktree(threadId, botId, dryRun) {
     console.error(`[gc] worktree remove failed for path=${worktreePath}:`, err);
   }
 }
+function isReclaimableSessionPath(p) {
+  const m = /[/\\]workspace[/\\]sessions[/\\]([^/\\]+)[/\\]?$/.exec(p);
+  if (m === null) return false;
+  const seg = m[1];
+  return seg !== "." && seg !== "..";
+}
+async function removeSessionDir(sessionPath, dryRun) {
+  if (!isReclaimableSessionPath(sessionPath)) {
+    console.error(`[gc] refusing to rm -rf non-session path: ${sessionPath}`);
+    return;
+  }
+  if (dryRun) {
+    console.log(`[gc] dry-run: would rm -rf ${sessionPath}`);
+    return;
+  }
+  console.log(`[gc] rm -rf ${sessionPath}`);
+  try {
+    await rm(sessionPath, { recursive: true, force: true });
+  } catch (err) {
+    console.error(`[gc] rm -rf failed for ${sessionPath}:`, err);
+  }
+}
+async function cleanupAgentSession(threadId, agentId, dryRun) {
+  if (!agentId) {
+    console.error(
+      `[gc] cleanupAgentSession: missing agentId for thread=${threadId}`
+    );
+    return;
+  }
+  let sessionPath;
+  try {
+    sessionPath = resolveAgentSessionPath(agentId, threadId);
+  } catch (err) {
+    console.error(`[gc] invalid session threadId=${threadId}:`, err);
+    return;
+  }
+  console.log(
+    `[gc] cleanup session thread=${threadId} path=${sessionPath} dryRun=${dryRun}`
+  );
+  let pids;
+  try {
+    pids = await findPidsByWorktree(sessionPath);
+  } catch (err) {
+    console.error(`[gc] pid lookup failed for path=${sessionPath}:`, err);
+    pids = [];
+  }
+  const alivePids = pids.filter(isPidAlive);
+  if (alivePids.length > 0) {
+    console.warn(
+      `[gc] skip live session thread=${threadId} path=${sessionPath}: runner pid(s) [${alivePids.join(", ")}] still alive \u2014 not reclaiming in-flight work`
+    );
+    return;
+  }
+  await removeSessionDir(sessionPath, dryRun);
+}
 
 // src/config/botLoader.ts
 import { readdir as readdir2, readFile as readFile5 } from "node:fs/promises";
@@ -126008,7 +126096,8 @@ stderr: ${stderr}` : "")
   return {
     events: generateEvents(),
     done,
-    kill: doKill
+    kill: doKill,
+    pid: child.pid ?? void 0
   };
 }
 var ClaudeRunner = class {
@@ -126365,7 +126454,8 @@ stderr: ${stderr}` : "")
   return {
     events: generateEvents(),
     done,
-    kill: doKill
+    kill: doKill,
+    pid: child.pid ?? void 0
   };
 }
 var CodexRunner = class {
@@ -126839,7 +126929,11 @@ async function runV2Mode({
         await upsertRuntimeEvent(larkwayHome(), bot.id, patch);
       }
     });
-    const housekeeping = new Housekeeping({ sessionStore, botId: bot.id });
+    const housekeeping = new Housekeeping({
+      sessionStore,
+      botId: bot.id,
+      runtime: bot.runtime
+    });
     const inst = {
       bot,
       client,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "larkway",
-  "version": "0.3.28",
+  "version": "0.3.29",
   "description": "Thin bridge: Feishu thread to local Claude Code CLI",
   "license": "MIT",
   "author": "Chuck Wu (chuckwu0)",