tabby-agentdeck 0.2.0 → 0.2.1

package/dist/bind.d.ts

@@ -0,0 +1,23 @@
+/**
+ * 훅 보고를 어느 탭에 붙일지 고르는 순수 규칙 — Angular/Tabby 에 기대지 않아 단위 테스트가 된다.
+ *
+ * 왜 PID 인가 — 예전 규칙 "처음 보고할 때의 활성 탭" 은 사용자가 방금 프롬프트를 넣은 탭이
+ * 곧 활성 탭이라는 가정인데, 파일 폴링이 400ms 마다 못 묶은 보고를 다시 시도하는 탓에
+ * **끝난 세션의 done 이 다음에 열리는 빈 탭을 붙잡았다** (2026-09-02 실측: 작업 중인 탭이
+ * "완료" 로, 그 탭의 진짜 세션은 주인이 있다며 거절돼 running 이 버려졌다).
+ *
+ * 훅은 자기 조상 프로세스 PID 를 함께 보낸다 — claude.exe → 탭 셸 → Tabby.exe 순서다.
+ * 탭마다 pty 가 띄운 셸 PID 를 알고 있으면 어느 탭의 보고인지 추측 없이 확정된다.
+ */
+export type BindMode = 'pid' | 'pid-miss' | 'legacy';
+export interface BindPick<T> {
+    tab: T | null;
+    /**
+     * pid      — 조상 PID 가 어떤 탭의 셸 PID 와 맞았다 (확정)
+     * pid-miss — pids 도 왔고 탭 PID 표도 있는데 맞는 탭이 없다. 활성 탭으로 추측하지 **않는다**
+     *            (탭 PID 표가 아직 안 채워진 것일 수 있으니 호출자는 다음 폴링에 다시 본다)
+     * legacy   — pids 가 없거나(옛 훅·수동 호출) 탭 PID 를 하나도 모른다. 호출자가 예전 활성 탭 규칙을 쓴다
+     */
+    mode: BindMode;
+}
+export declare function pickTabByPids<T>(pids: number[] | undefined, tabPids: Map<T, number[]>): BindPick<T>;

package/dist/index.js

@@ -845,6 +845,40 @@ const STATUS_STYLES = {
 };
 
 
+/***/ },
+
+/***/ "./src/bind.ts"
+/*!*********************!*\
+  !*** ./src/bind.ts ***!
+  \*********************/
+(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   pickTabByPids: () => (/* binding */ pickTabByPids)
+/* harmony export */ });
+function pickTabByPids(pids, tabPids) {
+    const wanted = (pids !== null && pids !== void 0 ? pids : []).filter(n => Number.isInteger(n) && n > 0);
+    let anyInfo = false;
+    for (const list of tabPids.values()) {
+        if (list.length) {
+            anyInfo = true;
+            break;
+        }
+    }
+    if (!wanted.length || !anyInfo) {
+        return { tab: null, mode: 'legacy' };
+    }
+    const set = new Set(wanted);
+    for (const [tab, list] of tabPids) {
+        if (list.some(p => set.has(p))) {
+            return { tab, mode: 'pid' };
+        }
+    }
+    return { tab: null, mode: 'pid-miss' };
+}
+
+
 /***/ },
 
 /***/ "./src/claudeHooks.ts"
@@ -4094,6 +4128,7 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony import */ var path__WEBPACK_IMPORTED_MODULE_5___default = /*#__PURE__*/__webpack_require__.n(path__WEBPACK_IMPORTED_MODULE_5__);
 /* harmony import */ var _status_service__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./status.service */ "./src/status.service.ts");
 /* harmony import */ var _claudeHooks__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./claudeHooks */ "./src/claudeHooks.ts");
+/* harmony import */ var _bind__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ./bind */ "./src/bind.ts");
 var __decorate = (undefined && undefined.__decorate) || function (decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
     if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -4111,6 +4146,8 @@ var __metadata = (undefined && undefined.__metadata) || function (k, v) {
 
 
 
+
+const DIAG_PATH = path__WEBPACK_IMPORTED_MODULE_5__.join(os__WEBPACK_IMPORTED_MODULE_4__.homedir(), '.agentdeck-diag.log');
 /**
  * 에이전트 훅 -> 사이드바 상태 채널. **기본으로 켜져 있다** (`notifyChannel`).
  *
@@ -4162,6 +4199,15 @@ let WorkNotifyService = class WorkNotifyService {
         this.timer = null;
         /** 폴링을 시작한 시각 — 이보다 오래된 파일은 지난 실행의 잔재다 */
         this.startedAt = 0;
+        /**
+         * 탭(루트) -> 그 안 패널들의 셸 PID. 훅이 보낸 조상 PID 와 맞춰 어느 탭의 보고인지 확정한다.
+         * pty 에 물어보는 비동기 작업이라 표로 들고 있고, 탭이 열릴 때와 2초마다 새로 채운다
+         */
+        this.tabPids = new Map();
+        this.pidRefreshing = false;
+        this.pollCount = 0;
+        /** 같은 매칭 실패를 폴링마다 diag 에 찍지 않기 위한 마지막 메시지 */
+        this.lastBindLog = new Map();
     }
     /**
      * 훅이 안 걸려 있으면 기동할 때 한 번 물어본다.
@@ -4238,9 +4284,15 @@ let WorkNotifyService = class WorkNotifyService {
             this.startedAt = Date.now();
             this.listen();
             this.timer = setInterval(() => this.poll(), 400);
+            void this.refreshPids();
+        });
+        // 새 탭의 셸 PID 는 세션이 붙은 뒤에야 나온다 — 조금 뒤에 한 번 더 채운다 (2초 주기 폴링도 있다)
+        this.app.tabOpened$.subscribe(() => {
+            setTimeout(() => { void this.refreshPids(); }, 1500);
         });
         // 탭이 닫히면 점유를 풀어야 그 자리를 다음 세션이 쓸 수 있다
         this.app.tabClosed$.subscribe(tab => {
+            this.tabPids.delete(tab);
             const sid = this.tabSession.get(tab);
             if (sid) {
                 this.tabSession.delete(tab);
@@ -4248,6 +4300,60 @@ let WorkNotifyService = class WorkNotifyService {
             }
         });
     }
+    /** 진단 한 줄 — deck.service 와 같은 파일(`~/.agentdeck-diag.log`)에 남긴다 */
+    diag(line) {
+        try {
+            fs__WEBPACK_IMPORTED_MODULE_2__.appendFileSync(DIAG_PATH, `${new Date().toISOString()} ${line}\n`);
+        }
+        catch {
+            // 진단일 뿐이다
+        }
+    }
+    tabName(tab) {
+        const anyTab = tab;
+        return JSON.stringify(String(anyTab.customTitle || anyTab.title || '').slice(0, 40));
+    }
+    /**
+     * 탭별 셸 PID 표를 새로 채운다. 로컬 pty 는 `session.pty.getPID()` 로 셸 PID 를 준다
+     * (tabby-local Session — gracefullyKillProcess 가 쓰는 그 경로). SSH 등 PID 가 없는 탭은 빈 목록.
+     */
+    async refreshPids() {
+        var _a;
+        if (this.pidRefreshing) {
+            return;
+        }
+        this.pidRefreshing = true;
+        try {
+            for (const root of [...this.app.tabs]) {
+                const anyRoot = root;
+                const panes = typeof anyRoot.getAllTabs === 'function' ? anyRoot.getAllTabs() : [root];
+                const pids = [];
+                for (const pane of panes) {
+                    const pty = (_a = pane === null || pane === void 0 ? void 0 : pane.session) === null || _a === void 0 ? void 0 : _a.pty;
+                    if (!pty || typeof pty.getPID !== 'function') {
+                        continue;
+                    }
+                    try {
+                        const pid = await pty.getPID();
+                        if (Number.isInteger(pid) && pid > 0) {
+                            pids.push(pid);
+                        }
+                    }
+                    catch {
+                        // 세션이 닫히는 중이다
+                    }
+                }
+                const prev = this.tabPids.get(root);
+                if (!prev || prev.join(',') !== pids.join(',')) {
+                    this.tabPids.set(root, pids);
+                    this.diag(`pid-map tab=${this.tabName(root)} pids=[${pids.join(',')}]`);
+                }
+            }
+        }
+        finally {
+            this.pidRefreshing = false;
+        }
+    }
     /** 진단용 */
     get debugDir() { return this.dir; }
     /** 진단용 — 듣고 있는 포트 (0 = TCP 채널이 안 떴다) */
@@ -4329,6 +4435,10 @@ let WorkNotifyService = class WorkNotifyService {
         }
     }
     poll() {
+        // 셸 PID 표는 2초마다 — 탭 안에서 셸을 다시 띄우거나 분할하면 바뀐다
+        if (++this.pollCount % 5 === 0) {
+            void this.refreshPids();
+        }
         let names;
         try {
             names = fs__WEBPACK_IMPORTED_MODULE_2__.readdirSync(this.dir);
@@ -4374,6 +4484,7 @@ let WorkNotifyService = class WorkNotifyService {
      * 들고 있는 이쪽이 한다 — 그래야 어느 경로로 들어오든 결과가 같다.
      */
     apply(data) {
+        var _a;
         if (!data || !data.sessionId) {
             return;
         }
@@ -4385,8 +4496,16 @@ let WorkNotifyService = class WorkNotifyService {
         if (this.applied.get(data.sessionId) === data.ts) {
             return;
         }
-        const tab = this.resolveTab(data.sessionId);
+        const tab = this.resolveTab(data.sessionId, data.pids);
         if (!tab) {
+            // pids 없는 보고(옛 훅·수동 호출)는 다시 봐도 결과가 같다. 그런데 폴링이 400ms 마다
+            // 되풀이하면 "활성 탭에 묶는다" 규칙이 다음에 열리는 빈 탭을 붙잡는다 — 끝난 세션의
+            // done 이 새 탭에 박히고, 그 탭의 진짜 세션은 주인이 있다며 거절됐다 (2026-09-02 실측).
+            // 적용한 것으로 쳐서 멈춘다. 다음 보고(새 ts)가 오면 그때 다시 시도한다.
+            // pids 가 있는 보고는 탭 PID 표가 채워지면 맞을 수 있으니 다음 폴링에 다시 본다.
+            if (!((_a = data.pids) === null || _a === void 0 ? void 0 : _a.length)) {
+                this.applied.set(data.sessionId, data.ts);
+            }
             return;
         }
         this.applied.set(data.sessionId, data.ts);
@@ -4406,17 +4525,40 @@ let WorkNotifyService = class WorkNotifyService {
         // 제목과 그 라벨을 각자 줄에 나눠 그린다(renderTab). 여기서 제목을 덮어쓸 이유가 없다.
     }
     /**
-     * 세션에 묶인 탭을 찾는다. 처음 보는 세션이면 지금 활성 탭에 묶는다.
+     * 세션에 묶인 탭을 찾는다.
+     *
+     * 1순위는 **프로세스 계보**다 — 훅이 보낸 조상 PID(claude.exe → 탭 셸 → Tabby) 에 어떤 탭의
+     * 셸 PID 가 들어 있으면 그 탭이다(bind.ts). 이미 다른 세션이 그 탭을 갖고 있어도 넘겨받는다:
+     * 같은 탭에서 claude 를 다시 띄우면 세션 id 가 바뀌는 게 정상이고, 이전 주인은 이미 죽은 세션이다.
+     * 알던 탭과 다른 탭이 맞으면 옮긴다 (`claude --resume` 을 다른 탭에서 띄운 경우).
+     *
+     * pids 가 왔는데 맞는 탭이 없으면 **추측하지 않고** null 이다 — 탭 PID 표가 아직 안 채워진 것일 수
+     * 있고, 그 경우 다음 폴링(400ms)에 다시 온다. 활성 탭으로 떨어지던 예전 규칙이 낸 사고가
+     * "끝난 세션의 done 이 새 탭에 박힘" 이었다 (2026-09-02 실측).
      *
-     * 단 그 탭을 이미 다른 세션이 점유했으면 **묶지 않는다**. 예전엔 이 검사가 없어서
-     * 여러 세션이 한 탭에 겹쳐 붙었고, 서로의 상태를 덮어써 "작업 중인 탭이 완료로,
-     * 끝난 탭이 진행 중으로" 뒤바뀌어 보였다. 못 묶은 세션은 사용자가 그 탭을 활성화하는
-     * 순간(= 다음 보고 때) 제 짝을 찾는다.
+     * pids 가 없는 보고(옛 훅·셸에서 사람이 부른 것)만 예전 규칙을 탄다 — 처음 보는 세션이면 지금 활성 탭.
+     * 단 그 탭을 이미 다른 세션이 점유했으면 묶지 않는다 (여러 세션이 한 탭에 겹쳐 붙어 서로의
+     * 상태를 덮어쓰던 2026-08-28 사고의 방지책).
      */
-    resolveTab(sessionId) {
+    resolveTab(sessionId, pids) {
         const known = this.sessionTab.get(sessionId);
-        if (known && this.app.tabs.includes(known)) {
-            return known;
+        const alive = known && this.app.tabs.includes(known) ? known : null;
+        const pick = (0,_bind__WEBPACK_IMPORTED_MODULE_8__.pickTabByPids)(pids, this.tabPids);
+        if (pick.mode === 'pid' && pick.tab) {
+            if (pick.tab !== alive) {
+                this.bind(sessionId, pick.tab, alive ? 'pid-move' : 'pid');
+            }
+            return pick.tab;
+        }
+        if (alive) {
+            return alive;
+        }
+        if (pick.mode === 'pid-miss') {
+            const table = [...this.tabPids.entries()]
+                .map(([tab, list]) => `${this.tabName(tab)}:[${list.join(',')}]`)
+                .join(' ');
+            this.bindLog(sessionId, `unbound (pid-miss) pids=[${(pids !== null && pids !== void 0 ? pids : []).join(',')}] tabs=${table}`);
+            return null;
         }
         const active = this.app.activeTab;
         if (!active) {
@@ -4424,12 +4566,36 @@ let WorkNotifyService = class WorkNotifyService {
         }
         const owner = this.tabSession.get(active);
         if (owner && owner !== sessionId) {
+            this.bindLog(sessionId, `unbound (legacy: active tab owned by ${owner.slice(0, 8)})`);
             return null;
         }
-        this.sessionTab.set(sessionId, active);
-        this.tabSession.set(active, sessionId);
+        this.bind(sessionId, active, 'legacy');
         return active;
     }
+    /** 세션 <-> 탭 을 묶고, 그 탭의 이전 주인과 이 세션의 이전 탭은 풀어 준다 */
+    bind(sessionId, tab, how) {
+        const prevOwner = this.tabSession.get(tab);
+        if (prevOwner && prevOwner !== sessionId) {
+            this.sessionTab.delete(prevOwner);
+        }
+        const prevTab = this.sessionTab.get(sessionId);
+        if (prevTab && prevTab !== tab && this.tabSession.get(prevTab) === sessionId) {
+            this.tabSession.delete(prevTab);
+        }
+        this.sessionTab.set(sessionId, tab);
+        this.tabSession.set(tab, sessionId);
+        this.lastBindLog.delete(sessionId);
+        this.diag(`bind sid=${sessionId.slice(0, 8)} via=${how} tab=${this.tabName(tab)}`
+            + (prevOwner && prevOwner !== sessionId ? ` (took over from ${prevOwner.slice(0, 8)})` : ''));
+    }
+    /** 매칭 실패는 폴링마다 반복되므로 같은 내용은 한 번만 남긴다 */
+    bindLog(sessionId, msg) {
+        if (this.lastBindLog.get(sessionId) === msg) {
+            return;
+        }
+        this.lastBindLog.set(sessionId, msg);
+        this.diag(`bind sid=${sessionId.slice(0, 8)} ${msg}`);
+    }
 };
 WorkNotifyService = __decorate([
     (0,_angular_core__WEBPACK_IMPORTED_MODULE_0__.Injectable)({ providedIn: 'root' }),