@tienne/gestalt 0.108.0 → 0.110.0

package/dist/src/peer/client.js

@@ -0,0 +1,51 @@
+import { createConnection } from 'node:net';
+export const DAEMON_NOT_RUNNING = '`gestalt peer daemon`을 먼저 실행해 주세요';
+export class DaemonUnavailableError extends Error {
+    socketPath;
+    constructor(socketPath) {
+        super(`peer 데몬에 연결하지 못했어요 (${socketPath}). ${DAEMON_NOT_RUNNING}`);
+        this.socketPath = socketPath;
+        this.name = 'DaemonUnavailableError';
+    }
+}
+/** 데몬에 요청 한 줄을 보내고 답 한 줄을 받는다 */
+export function request(sock, req, timeoutMs = 5_000) {
+    return new Promise((resolve, reject) => {
+        const socket = createConnection(sock);
+        let buf = '';
+        let settled = false;
+        const finish = (fn) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            socket.destroy();
+            fn();
+        };
+        const timer = setTimeout(() => finish(() => reject(new Error(`peer 데몬이 ${timeoutMs}ms 안에 답하지 않았어요`))), timeoutMs);
+        socket.setEncoding('utf8');
+        socket.once('connect', () => socket.write(JSON.stringify(req) + '\n'));
+        socket.on('data', (chunk) => {
+            buf += chunk;
+            const nl = buf.indexOf('\n');
+            if (nl === -1)
+                return;
+            const line = buf.slice(0, nl);
+            finish(() => {
+                try {
+                    resolve(JSON.parse(line));
+                }
+                catch {
+                    reject(new Error('peer 데몬 답이 JSON이 아니에요'));
+                }
+            });
+        });
+        socket.once('error', (err) => {
+            finish(() => reject(err.code === 'ENOENT' || err.code === 'ECONNREFUSED'
+                ? new DaemonUnavailableError(sock)
+                : err));
+        });
+        socket.once('close', () => finish(() => reject(new Error('peer 데몬이 답 없이 연결을 끊었어요'))));
+    });
+}
+//# sourceMappingURL=client.js.map

package/dist/src/peer/client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.js","sourceRoot":"","sources":["../../../src/peer/client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAG5C,MAAM,CAAC,MAAM,kBAAkB,GAAG,mCAAmC,CAAC;AAEtE,MAAM,OAAO,sBAAuB,SAAQ,KAAK;IAC1B;IAArB,YAAqB,UAAkB;QACrC,KAAK,CAAC,uBAAuB,UAAU,MAAM,kBAAkB,EAAE,CAAC,CAAC;QADhD,eAAU,GAAV,UAAU,CAAQ;QAErC,IAAI,CAAC,IAAI,GAAG,wBAAwB,CAAC;IACvC,CAAC;CACF;AAED,iCAAiC;AACjC,MAAM,UAAU,OAAO,CACrB,IAAY,EACZ,GAAgB,EAChB,SAAS,GAAG,KAAK;IAEjB,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;QACrC,MAAM,MAAM,GAAG,gBAAgB,CAAC,IAAI,CAAC,CAAC;QACtC,IAAI,GAAG,GAAG,EAAE,CAAC;QACb,IAAI,OAAO,GAAG,KAAK,CAAC;QACpB,MAAM,MAAM,GAAG,CAAC,EAAc,EAAQ,EAAE;YACtC,IAAI,OAAO;gBAAE,OAAO;YACpB,OAAO,GAAG,IAAI,CAAC;YACf,YAAY,CAAC,KAAK,CAAC,CAAC;YACpB,MAAM,CAAC,OAAO,EAAE,CAAC;YACjB,EAAE,EAAE,CAAC;QACP,CAAC,CAAC;QACF,MAAM,KAAK,GAAG,UAAU,CACtB,GAAG,EAAE,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,IAAI,KAAK,CAAC,YAAY,SAAS,gBAAgB,CAAC,CAAC,CAAC,EAC5E,SAAS,CACV,CAAC;QAEF,MAAM,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;QAC3B,MAAM,CAAC,IAAI,CAAC,SAAS,EAAE,GAAG,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC;QACvE,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,CAAC,KAAa,EAAE,EAAE;YAClC,GAAG,IAAI,KAAK,CAAC;YACb,MAAM,EAAE,GAAG,GAAG,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;YAC7B,IAAI,EAAE,KAAK,CAAC,CAAC;gBAAE,OAAO;YACtB,MAAM,IAAI,GAAG,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;YAC9B,MAAM,CAAC,GAAG,EAAE;gBACV,IAAI,CAAC;oBACH,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAoB,CAAC,CAAC;gBAC/C,CAAC;gBAAC,MAAM,CAAC;oBACP,MAAM,CAAC,IAAI,KAAK,CAAC,uBAAuB,CAAC,CAAC,CAAC;gBAC7C,CAAC;YACH,CAAC,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;QACH,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,GAA0B,EAAE,EAAE;YAClD,MAAM,CAAC,GAAG,EAAE,CACV,MAAM,CACJ,GAAG,CAAC,IAAI,KAAK,QAAQ,IAAI,GAAG,CAAC,IAAI,KAAK,cAAc;gBAClD,CAAC,CAAC,IAAI,sBAAsB,CAAC,IAAI,CAAC;gBAClC,CAAC,CAAC,GAAG,CACR,CACF,CAAC;QACJ,CAAC,CAAC,CAAC;QACH,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,GAAG,EAAE,CACxB,MAAM,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,IAAI,KAAK,CAAC,wBAAwB,CAAC,CAAC,CAAC,CAC1D,CAAC;IACJ,CAAC,CAAC,CAAC;AACL,CAAC"}

package/dist/src/peer/daemon.d.ts

@@ -0,0 +1,83 @@
+import type { PeerRequest, PeerResponse } from './protocol.js';
+import type { PeerNetworkOptions } from './network.js';
+export interface PeerDaemonOptions {
+    root: string;
+    /** 기본은 `<root>/state.db`. 테스트는 `.gestalt-test/peer-*.db`를 넘긴다 */
+    dbPath?: string;
+    /** 대화 기록을 다시 읽는 간격 */
+    pollMs?: number;
+    /** 가리기에서 `~`로 바꿀 홈. 테스트가 가짜 홈을 넣는다 */
+    home?: string;
+    /** 릴레이에 다시 붙는 간격 같은 것. 테스트가 줄인다 */
+    network?: PeerNetworkOptions['transport'];
+}
+/**
+ * `gestalt peer daemon`. 공유를 들고 대화 기록을 따라 읽어 로컬 뷰어로 흘린다. 팀에
+ * 들었으면 팀 릴레이에 붙어 팀원에게 공유를 넘기고 팀원 공유를 받아 로컬 뷰어로 옮긴다.
+ *
+ * 바깥으로 나가는 연결은 팀 릴레이 하나다. 소켓은 0600, 디렉토리는 0700이라 같은 OS
+ * 사용자만 명령을 넣는다. 뷰어는 `127.0.0.1`에만 붙는다.
+ */
+export declare class PeerDaemon {
+    private readonly options;
+    private ipc;
+    private viewer;
+    private state;
+    private network;
+    private key;
+    private lock;
+    private shares;
+    private timer;
+    private startedAt;
+    private conns;
+    /** 이 데몬이 만든 소켓 파일. stop은 소켓 자리가 아직 이것일 때만 지운다 */
+    private ownSocket;
+    private readonly sock;
+    /** listen할 임시 이름. 권한을 좁힌 뒤 진짜 이름으로 링크한다 */
+    private readonly tmpSock;
+    private readonly pollMs;
+    constructor(options: PeerDaemonOptions);
+    get socketPath(): string;
+    get viewerPort(): number | undefined;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    /** 테스트가 타이머를 기다리지 않고 한 번 돌릴 때 쓴다 */
+    tick(now?: number): void;
+    /**
+     * closeShare는 DB에 쓰다가 던질 수 있다. tick에서 던지면 뒤 공유를 못 돌고 stop에서
+     * 던지면 뷰어와 IPC 서버와 소켓 파일 정리까지 건너뛴다. unshare에서 던지면 공유는 이미
+     * 종료됐는데 실패로 답해서 다시 unshare하면 열린 공유가 아니라고 나온다. 공유는 던지기
+     * 전에 이미 맵에서 빠지므로 남는 건 DB 기록 하나다.
+     */
+    private closeShareSafely;
+    handle(req: PeerRequest): PeerResponse | Promise<PeerResponse>;
+    private withNetwork;
+    private withNetworkAsync;
+    private viewerUrl;
+    private announceShares;
+    private openShare;
+    private closeShare;
+    private info;
+    private status;
+    /**
+     * 남은 소켓 파일을 치운다. 누가 받고 있으면 데몬이 이미 떠 있는 거라 던진다.
+     * 소켓이 아닌 파일이면 안 지운다 — 경로를 잘못 줬을 때 남의 파일을 지우지 않게.
+     *
+     * 데몬 잠금(`peer.lock`)을 쥔 뒤에만 부른다. 잠금을 쥔 데몬은 하나라서 확인하고 지우는
+     * 사이에 다른 데몬이 새 소켓을 만들 수 없다. 잠금 없이 소켓을 만드는 옛 버전 데몬이
+     * 끼어드는 경우만 남아서 지우기 직전에 같은 파일인지 한 번 더 본다.
+     */
+    private clearStaleSocket;
+    /**
+     * 임시 이름으로 listen하고 0600으로 좁힌 뒤 진짜 이름에 하드 링크를 건다.
+     *
+     * 진짜 이름에 바로 listen하면 net.Server.close가 그 경로를 무조건 지운다(libuv). 그새
+     * 다른 데몬이 그 자리를 차지했으면 남의 소켓이 사라진다. 링크는 이름이 이미 있으면
+     * 실패하므로 동시에 뜬 데몬끼리 서로 덮어쓰지도 않는다.
+     */
+    private listenIpc;
+    private removeOwnSocket;
+    private serve;
+    private answer;
+}
+//# sourceMappingURL=daemon.d.ts.map

package/dist/src/peer/daemon.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"daemon.d.ts","sourceRoot":"","sources":["../../../src/peer/daemon.ts"],"names":[],"mappings":"AAqBA,OAAO,KAAK,EAAgB,WAAW,EAAE,YAAY,EAAa,MAAM,eAAe,CAAC;AAQxF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAGvD,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,iEAAiE;IACjE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,sBAAsB;IACtB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,sCAAsC;IACtC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,mCAAmC;IACnC,OAAO,CAAC,EAAE,kBAAkB,CAAC,WAAW,CAAC,CAAC;CAC3C;AAsBD;;;;;;GAMG;AACH,qBAAa,UAAU;IAkBT,OAAO,CAAC,QAAQ,CAAC,OAAO;IAjBpC,OAAO,CAAC,GAAG,CAAuB;IAClC,OAAO,CAAC,MAAM,CAAe;IAC7B,OAAO,CAAC,KAAK,CAA0B;IACvC,OAAO,CAAC,OAAO,CAA4B;IAC3C,OAAO,CAAC,GAAG,CAA2B;IACtC,OAAO,CAAC,IAAI,CAA2B;IACvC,OAAO,CAAC,MAAM,CAAgC;IAC9C,OAAO,CAAC,KAAK,CAA+B;IAC5C,OAAO,CAAC,SAAS,CAAK;IACtB,OAAO,CAAC,KAAK,CAAqB;IAClC,iDAAiD;IACjD,OAAO,CAAC,SAAS,CAAuB;IACxC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAS;IAC9B,2CAA2C;IAC3C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;gBAEH,OAAO,EAAE,iBAAiB;IAevD,IAAI,UAAU,IAAI,MAAM,CAEvB;IAED,IAAI,UAAU,IAAI,MAAM,GAAG,SAAS,CAEnC;IAEK,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IA6CtB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAiC3B,oCAAoC;IACpC,IAAI,CAAC,GAAG,SAAa,GAAG,IAAI;IAyB5B;;;;;OAKG;IACH,OAAO,CAAC,gBAAgB;IAQxB,MAAM,CAAC,GAAG,EAAE,WAAW,GAAG,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC;IAuD9D,OAAO,CAAC,WAAW;YASL,gBAAgB;IAS9B,OAAO,CAAC,SAAS;IAIjB,OAAO,CAAC,cAAc;IAItB,OAAO,CAAC,SAAS;IA8DjB,OAAO,CAAC,UAAU;IAUlB,OAAO,CAAC,IAAI;IAuBZ,OAAO,CAAC,MAAM;IAed;;;;;;;OAOG;YACW,gBAAgB;IAkB9B;;;;;;OAMG;IACH,OAAO,CAAC,SAAS;IA+BjB,OAAO,CAAC,eAAe;IAWvB,OAAO,CAAC,KAAK;YAoCC,MAAM;CAoBrB"}

package/dist/src/peer/daemon.js

@@ -0,0 +1,516 @@
+import { randomBytes } from 'node:crypto';
+import { chmodSync, existsSync, linkSync, lstatSync, realpathSync, statSync, unlinkSync, } from 'node:fs';
+import { createConnection, createServer } from 'node:net';
+import { isAbsolute, join } from 'node:path';
+import { isToolsLevel } from './redact.js';
+import { ensurePrivateDir, MAX_SOCKET_PATH_BYTES, socketPath, statePath } from './paths.js';
+import { PeerState } from './state.js';
+import { ShareStream } from './share.js';
+import { ViewerServer } from './viewer.js';
+import { DEFAULT_EXPIRES_MINUTES, MAX_EXPIRES_MINUTES, MAX_REQUEST_BYTES } from './protocol.js';
+import { isSessionId } from './locate.js';
+import { errMessage } from './errors.js';
+import { loadOrCreateMachineKey } from './keys.js';
+import { acquireDaemonLock, releaseDaemonLock } from './lock.js';
+import { PeerNetwork, PeerNetworkError } from './network.js';
+const DEFAULT_POLL_MS = 500;
+/** stop이 IPC 서버가 닫히길 기다리는 상한. 넘으면 기다리지 않고 정리를 마친다 */
+const STOP_TIMEOUT_MS = 2_000;
+/**
+ * `gestalt peer daemon`. 공유를 들고 대화 기록을 따라 읽어 로컬 뷰어로 흘린다. 팀에
+ * 들었으면 팀 릴레이에 붙어 팀원에게 공유를 넘기고 팀원 공유를 받아 로컬 뷰어로 옮긴다.
+ *
+ * 바깥으로 나가는 연결은 팀 릴레이 하나다. 소켓은 0600, 디렉토리는 0700이라 같은 OS
+ * 사용자만 명령을 넣는다. 뷰어는 `127.0.0.1`에만 붙는다.
+ */
+export class PeerDaemon {
+    options;
+    ipc = null;
+    viewer;
+    state = null;
+    network = null;
+    key = null;
+    lock = null;
+    shares = new Map();
+    timer = null;
+    startedAt = 0;
+    conns = new Set();
+    /** 이 데몬이 만든 소켓 파일. stop은 소켓 자리가 아직 이것일 때만 지운다 */
+    ownSocket = null;
+    sock;
+    /** listen할 임시 이름. 권한을 좁힌 뒤 진짜 이름으로 링크한다 */
+    tmpSock;
+    pollMs;
+    constructor(options) {
+        this.options = options;
+        this.sock = socketPath(options.root);
+        this.tmpSock = join(options.root, `${process.pid}.s`);
+        this.pollMs = options.pollMs ?? DEFAULT_POLL_MS;
+        this.viewer = new ViewerServer({
+            lookup: (id) => {
+                const s = this.shares.get(id);
+                if (s)
+                    return { stream: s.stream, token: s.token };
+                return this.network?.lookupWatch(id);
+            },
+            onConnect: (id) => this.state?.audit('viewer_connect', id),
+            onDisconnect: (id) => this.state?.audit('viewer_disconnect', id),
+        });
+    }
+    get socketPath() {
+        return this.sock;
+    }
+    get viewerPort() {
+        return this.viewer.port;
+    }
+    async start() {
+        for (const path of [this.sock, this.tmpSock]) {
+            if (Buffer.byteLength(path) > MAX_SOCKET_PATH_BYTES) {
+                throw new Error(`소켓 경로가 너무 길어요(${MAX_SOCKET_PATH_BYTES}바이트 한도): ${path}`);
+            }
+        }
+        ensurePrivateDir(this.options.root);
+        const lock = await acquireDaemonLock(this.options.root, this.sock);
+        let state = null;
+        try {
+            await this.clearStaleSocket();
+            state = new PeerState(this.options.dbPath ?? statePath(this.options.root));
+            this.state = state;
+            for (const id of state.closeDangling('daemon_restart')) {
+                state.audit('share_close', id, 'daemon_restart');
+            }
+            this.key = loadOrCreateMachineKey(this.options.root);
+            await this.viewer.start(0);
+            await this.listenIpc();
+        }
+        catch (err) {
+            // stop()은 부르지 않는다. 여기까지 연 건 뷰어와 DB뿐이고 stop은 소켓 자리까지
+            // 치우는 경로라 반쯤 뜬 데몬이 이미 떠 있는 다른 데몬의 자리를 건드릴 수 있다
+            await this.viewer.stop();
+            state?.close();
+            this.state = null;
+            releaseDaemonLock(lock);
+            throw err;
+        }
+        this.lock = lock;
+        this.network = new PeerNetwork({
+            state,
+            key: this.key,
+            lookupShare: (id) => {
+                const s = this.shares.get(id);
+                return s ? { stream: s.stream, shareKey: s.shareKey } : undefined;
+            },
+            transport: this.options.network,
+        });
+        this.network.start();
+        this.startedAt = Date.now();
+        this.timer = setInterval(() => this.tick(), this.pollMs);
+        this.timer.unref();
+    }
+    async stop() {
+        if (this.timer)
+            clearInterval(this.timer);
+        this.timer = null;
+        for (const id of [...this.shares.keys()])
+            this.closeShareSafely(id, 'daemon_stop');
+        const ipc = this.ipc;
+        this.ipc = null;
+        const network = this.network;
+        this.network = null;
+        try {
+            await network?.stop().catch((err) => {
+                process.stderr.write(`[peer] network stop failed: ${errMessage(err)}\n`);
+            });
+            await this.viewer.stop();
+            if (ipc) {
+                // 열린 연결이 남아 있으면 close 콜백이 안 불려 stop이 끝나지 않는다
+                for (const c of this.conns)
+                    c.destroy();
+                await new Promise((resolve) => {
+                    const timer = setTimeout(resolve, STOP_TIMEOUT_MS);
+                    ipc.close(() => {
+                        clearTimeout(timer);
+                        resolve();
+                    });
+                });
+            }
+        }
+        finally {
+            this.removeOwnSocket();
+            this.state?.close();
+            this.state = null;
+            if (this.lock)
+                releaseDaemonLock(this.lock);
+            this.lock = null;
+        }
+    }
+    /** 테스트가 타이머를 기다리지 않고 한 번 돌릴 때 쓴다 */
+    tick(now = Date.now()) {
+        for (const [id, share] of [...this.shares]) {
+            try {
+                if (now >= share.expiresAt) {
+                    this.closeShareSafely(id, 'expired');
+                    continue;
+                }
+                const before = share.stream.unknownLines;
+                const { unknownGrew } = share.stream.poll();
+                if (unknownGrew) {
+                    const added = share.stream.unknownLines - before;
+                    this.state?.audit('unknown_lines', id, JSON.stringify({ added, claudeVersion: share.stream.claudeVersion ?? null }));
+                }
+            }
+            catch (err) {
+                // setInterval 밖으로 던지면 데몬이 죽는다. 그 공유만 종료하고 나머지는 계속 돈다
+                process.stderr.write(`[peer] share ${id} failed: ${errMessage(err)}\n`);
+                this.closeShareSafely(id, 'error');
+            }
+        }
+    }
+    /**
+     * closeShare는 DB에 쓰다가 던질 수 있다. tick에서 던지면 뒤 공유를 못 돌고 stop에서
+     * 던지면 뷰어와 IPC 서버와 소켓 파일 정리까지 건너뛴다. unshare에서 던지면 공유는 이미
+     * 종료됐는데 실패로 답해서 다시 unshare하면 열린 공유가 아니라고 나온다. 공유는 던지기
+     * 전에 이미 맵에서 빠지므로 남는 건 DB 기록 하나다.
+     */
+    closeShareSafely(id, reason) {
+        try {
+            this.closeShare(id, reason);
+        }
+        catch (err) {
+            process.stderr.write(`[peer] share ${id} close failed: ${errMessage(err)}\n`);
+        }
+    }
+    handle(req) {
+        switch (req.op) {
+            case 'ping':
+                return { ok: true, result: 'pong' };
+            case 'status':
+                return { ok: true, result: this.status() };
+            case 'shares':
+                return { ok: true, result: [...this.shares.keys()].map((id) => this.info(id)) };
+            case 'share':
+                return this.openShare(req);
+            case 'unshare': {
+                if (typeof req.id !== 'string' || !this.shares.has(req.id)) {
+                    return { ok: false, error: `열린 공유가 아니에요: ${String(req.id)}` };
+                }
+                this.closeShareSafely(req.id, 'unshare');
+                return { ok: true, result: { id: req.id } };
+            }
+            case 'init':
+                return this.withNetwork((n) => n.init(String(req.person), String(req.relay)));
+            case 'invite':
+                return this.withNetwork((n) => n.invite(String(req.person)));
+            case 'join': {
+                const timeout = req.timeoutMs;
+                return this.withNetworkAsync((n) => n.join(String(req.code), Number.isFinite(timeout) && timeout > 0 ? timeout : undefined));
+            }
+            case 'remove':
+                return this.withNetwork((n) => n.remove(String(req.person)));
+            case 'members':
+                return this.withNetwork((n) => n.members());
+            case 'watch':
+                return this.withNetworkAsync(async (n) => {
+                    const w = await n.watch(String(req.link));
+                    return { id: w.id, share: w.share, owner: w.owner, url: this.viewerUrl(w.id, w.token) };
+                });
+            case 'watches':
+                return this.withNetwork((n) => n.listWatches().map((w) => ({
+                    ...w,
+                    url: this.viewerUrl(w.id, n.lookupWatch(w.id).token),
+                })));
+            case 'unwatch': {
+                const id = String(req.id);
+                return this.withNetwork((n) => {
+                    if (!n.unwatch(id))
+                        throw new PeerNetworkError(`보고 있는 공유가 아니에요: ${id}`);
+                    return { id };
+                });
+            }
+            default:
+                return { ok: false, error: `모르는 요청이에요: ${String(req.op)}` };
+        }
+    }
+    withNetwork(fn) {
+        if (!this.network)
+            return { ok: false, error: '데몬이 아직 안 떴어요' };
+        try {
+            return { ok: true, result: fn(this.network) };
+        }
+        catch (err) {
+            return { ok: false, error: errMessage(err) };
+        }
+    }
+    async withNetworkAsync(fn) {
+        if (!this.network)
+            return { ok: false, error: '데몬이 아직 안 떴어요' };
+        try {
+            return { ok: true, result: await fn(this.network) };
+        }
+        catch (err) {
+            return { ok: false, error: errMessage(err) };
+        }
+    }
+    viewerUrl(id, token) {
+        return `http://127.0.0.1:${this.viewer.port}/s/${id}?t=${token}`;
+    }
+    announceShares() {
+        this.network?.announce([...this.shares.keys()]);
+    }
+    openShare(req) {
+        const path = req.transcriptPath;
+        if (typeof path !== 'string' || !isAbsolute(path)) {
+            return { ok: false, error: 'transcriptPath는 절대경로여야 해요' };
+        }
+        // 아무 파일이나 열지 못하게 대화 기록 꼴만 받는다
+        if (!path.endsWith('.jsonl'))
+            return { ok: false, error: '.jsonl 파일만 공유할 수 있어요' };
+        let real;
+        try {
+            real = realpathSync(path);
+        }
+        catch {
+            return { ok: false, error: `대화 기록 파일이 없어요: ${path}` };
+        }
+        // `x.jsonl -> 다른 파일` 심링크는 이름만 맞는다. 검사와 따라 읽기를 실제 경로에 건다
+        if (!real.endsWith('.jsonl'))
+            return { ok: false, error: '.jsonl 파일만 공유할 수 있어요' };
+        try {
+            if (!statSync(real).isFile())
+                return { ok: false, error: `파일이 아니에요: ${path}` };
+        }
+        catch {
+            return { ok: false, error: `대화 기록 파일이 없어요: ${path}` };
+        }
+        if (req.sessionId !== undefined && !isSessionId(req.sessionId)) {
+            return { ok: false, error: 'sessionId 형식이 아니에요' };
+        }
+        const tools = req.tools ?? 'summary';
+        if (!isToolsLevel(tools))
+            return { ok: false, error: '--tools는 full, summary, none 중 하나예요' };
+        const minutes = req.expiresMinutes ?? DEFAULT_EXPIRES_MINUTES;
+        if (!Number.isFinite(minutes) || minutes <= 0 || minutes > MAX_EXPIRES_MINUTES) {
+            return { ok: false, error: `--expires는 1~${MAX_EXPIRES_MINUTES}분이에요` };
+        }
+        const id = randomBytes(6).toString('base64url');
+        const token = randomBytes(24).toString('base64url');
+        const shareKey = randomBytes(32).toString('base64url');
+        const createdAt = Date.now();
+        const expiresAt = createdAt + Math.round(minutes * 60_000);
+        const stream = new ShareStream({ id, transcriptPath: real, tools, home: this.options.home });
+        stream.poll();
+        this.shares.set(id, {
+            stream,
+            token,
+            shareKey,
+            sessionId: req.sessionId ?? null,
+            createdAt,
+            expiresAt,
+        });
+        this.state.insertShare({
+            id,
+            sessionId: req.sessionId ?? null,
+            transcriptPath: real,
+            tools,
+            createdAt,
+            expiresAt,
+        });
+        this.state.audit('share_open', id, JSON.stringify({ tools, expiresAt }));
+        this.announceShares();
+        return { ok: true, result: this.info(id) };
+    }
+    closeShare(id, reason) {
+        const share = this.shares.get(id);
+        if (!share)
+            return;
+        this.shares.delete(id);
+        share.stream.close(reason);
+        this.announceShares();
+        this.state?.closeShare(id, reason);
+        this.state?.audit('share_close', id, reason);
+    }
+    info(id) {
+        const s = this.shares.get(id);
+        if (!s)
+            return undefined;
+        return {
+            id,
+            sessionId: s.sessionId,
+            transcriptPath: s.stream.transcriptPath,
+            tools: s.stream.tools,
+            createdAt: s.createdAt,
+            expiresAt: s.expiresAt,
+            status: s.stream.currentStatus,
+            viewers: s.stream.viewerCount,
+            events: s.stream.eventCount,
+            unknownLines: s.stream.unknownLines,
+            failedLines: s.stream.failedLines,
+            oversizedLines: s.stream.oversizedLines,
+            droppedEvents: s.stream.droppedEvents,
+            title: s.stream.sessionTitle,
+            url: this.viewerUrl(id, s.token),
+            link: this.network?.linkFor(id, s.shareKey),
+        };
+    }
+    status() {
+        let viewers = 0;
+        for (const s of this.shares.values())
+            viewers += s.stream.viewerCount;
+        return {
+            pid: process.pid,
+            root: this.options.root,
+            viewerPort: this.viewer.port ?? 0,
+            startedAt: this.startedAt,
+            shares: this.shares.size,
+            viewers,
+            machineKey: this.key?.id ?? '',
+            team: this.network?.status() ?? null,
+        };
+    }
+    /**
+     * 남은 소켓 파일을 치운다. 누가 받고 있으면 데몬이 이미 떠 있는 거라 던진다.
+     * 소켓이 아닌 파일이면 안 지운다 — 경로를 잘못 줬을 때 남의 파일을 지우지 않게.
+     *
+     * 데몬 잠금(`peer.lock`)을 쥔 뒤에만 부른다. 잠금을 쥔 데몬은 하나라서 확인하고 지우는
+     * 사이에 다른 데몬이 새 소켓을 만들 수 없다. 잠금 없이 소켓을 만드는 옛 버전 데몬이
+     * 끼어드는 경우만 남아서 지우기 직전에 같은 파일인지 한 번 더 본다.
+     */
+    async clearStaleSocket() {
+        if (!existsSync(this.sock))
+            return;
+        const stale = lstatSync(this.sock);
+        if (!stale.isSocket()) {
+            throw new Error(`소켓 자리에 다른 파일이 있어요: ${this.sock}`);
+        }
+        const alive = await new Promise((resolve) => {
+            const c = createConnection(this.sock);
+            c.once('connect', () => {
+                c.destroy();
+                resolve(true);
+            });
+            c.once('error', () => resolve(false));
+        });
+        if (alive)
+            throw new Error(`데몬이 이미 떠 있어요: ${this.sock}`);
+        if (sameFile(this.sock, stale))
+            unlinkSync(this.sock);
+    }
+    /**
+     * 임시 이름으로 listen하고 0600으로 좁힌 뒤 진짜 이름에 하드 링크를 건다.
+     *
+     * 진짜 이름에 바로 listen하면 net.Server.close가 그 경로를 무조건 지운다(libuv). 그새
+     * 다른 데몬이 그 자리를 차지했으면 남의 소켓이 사라진다. 링크는 이름이 이미 있으면
+     * 실패하므로 동시에 뜬 데몬끼리 서로 덮어쓰지도 않는다.
+     */
+    listenIpc() {
+        const tmp = this.tmpSock;
+        if (existsSync(tmp) && lstatSync(tmp).isSocket())
+            unlinkSync(tmp);
+        return new Promise((resolve, reject) => {
+            const server = createServer((socket) => this.serve(socket));
+            server.once('error', reject);
+            server.listen(tmp, () => {
+                server.off('error', reject);
+                server.on('error', (err) => process.stderr.write(`[peer] ipc error: ${err.message}\n`));
+                try {
+                    chmodSync(tmp, 0o600);
+                    linkSync(tmp, this.sock);
+                }
+                catch (err) {
+                    server.close();
+                    const code = err.code;
+                    reject(code === 'EEXIST' ? new Error(`데몬이 이미 떠 있어요: ${this.sock}`) : err);
+                    return;
+                }
+                try {
+                    unlinkSync(tmp);
+                }
+                catch {
+                    // 남아도 close가 지운다
+                }
+                const st = lstatSync(this.sock);
+                this.ownSocket = { dev: st.dev, ino: st.ino };
+                this.ipc = server;
+                resolve();
+            });
+        });
+    }
+    removeOwnSocket() {
+        const own = this.ownSocket;
+        this.ownSocket = null;
+        if (!own)
+            return;
+        try {
+            if (sameFile(this.sock, own))
+                unlinkSync(this.sock);
+        }
+        catch {
+            // 이미 없으면 그만이다
+        }
+    }
+    serve(socket) {
+        let buf = '';
+        let rejected = false;
+        // 오래 걸리는 요청(join, watch)이 있어도 답은 받은 차례대로 쓴다
+        let queue = Promise.resolve();
+        this.conns.add(socket);
+        socket.on('close', () => this.conns.delete(socket));
+        socket.setEncoding('utf8');
+        socket.on('error', () => socket.destroy());
+        socket.on('data', (chunk) => {
+            if (rejected)
+                return;
+            buf += chunk;
+            if (Buffer.byteLength(buf) > MAX_REQUEST_BYTES) {
+                rejected = true;
+                buf = '';
+                // 바로 destroy하면 거절 답이 나가기 전에 끊길 수 있다
+                socket.end(JSON.stringify({ ok: false, error: '요청이 너무 커요' }) + '\n', () => socket.destroy());
+                return;
+            }
+            let nl = buf.indexOf('\n');
+            while (nl !== -1) {
+                const line = buf.slice(0, nl);
+                buf = buf.slice(nl + 1);
+                if (line.trim() !== '') {
+                    queue = queue.then(async () => {
+                        const res = await this.answer(line);
+                        if (!socket.destroyed)
+                            socket.write(JSON.stringify(res) + '\n');
+                    });
+                }
+                nl = buf.indexOf('\n');
+            }
+        });
+    }
+    async answer(line) {
+        let req;
+        try {
+            req = JSON.parse(line);
+        }
+        catch {
+            return { ok: false, error: 'JSON이 아니에요' };
+        }
+        if (typeof req !== 'object' ||
+            req === null ||
+            typeof req.op !== 'string') {
+            return { ok: false, error: 'op가 없어요' };
+        }
+        try {
+            return await this.handle(req);
+        }
+        catch (err) {
+            return { ok: false, error: errMessage(err) };
+        }
+    }
+}
+function sameFile(path, id) {
+    try {
+        const st = lstatSync(path);
+        return st.dev === id.dev && st.ino === id.ino;
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=daemon.js.map