@pimote/pimote 0.1.0

package/server/dist/session-metadata.js

@@ -0,0 +1,81 @@
+import { readFile, writeFile, mkdir, rename } from 'node:fs/promises';
+import { dirname } from 'node:path';
+export class FileSessionMetadataStore {
+    filePath;
+    sessions = new Map();
+    constructor(filePath) {
+        this.filePath = filePath;
+    }
+    async initialize() {
+        try {
+            const raw = await readFile(this.filePath, 'utf-8');
+            const parsed = JSON.parse(raw);
+            const entries = parsed.sessions ?? {};
+            this.sessions = new Map(Object.entries(entries).filter(([key, value]) => typeof key === 'string' &&
+                typeof value === 'object' &&
+                value !== null &&
+                (value.archived === undefined || typeof value.archived === 'boolean') &&
+                (value.archivedAt === undefined || typeof value.archivedAt === 'string')));
+        }
+        catch (err) {
+            if (err && typeof err === 'object' && 'code' in err && err.code === 'ENOENT') {
+                this.sessions = new Map();
+                return;
+            }
+            throw new Error('Failed to load session metadata', { cause: err });
+        }
+    }
+    get(path) {
+        return this.sessions.get(path);
+    }
+    isArchived(path) {
+        return this.sessions.get(path)?.archived === true;
+    }
+    getArchivedLookup(paths) {
+        return new Map(paths.map((path) => [path, this.isArchived(path)]));
+    }
+    async setArchived(path, archived) {
+        const existing = this.sessions.get(path) ?? {};
+        if (archived) {
+            this.sessions.set(path, {
+                ...existing,
+                archived: true,
+                archivedAt: existing.archivedAt ?? new Date().toISOString(),
+            });
+        }
+        else if (Object.keys(existing).length === 0) {
+            return;
+        }
+        else {
+            const next = { ...existing, archived: false };
+            delete next.archivedAt;
+            if (!next.archived) {
+                this.sessions.delete(path);
+            }
+            else {
+                this.sessions.set(path, next);
+            }
+        }
+        await this.save();
+    }
+    async delete(path) {
+        if (!this.sessions.delete(path))
+            return;
+        await this.save();
+    }
+    async save() {
+        try {
+            await mkdir(dirname(this.filePath), { recursive: true });
+            const tmpPath = this.filePath + '.tmp';
+            const payload = {
+                version: 1,
+                sessions: Object.fromEntries(this.sessions.entries()),
+            };
+            await writeFile(tmpPath, JSON.stringify(payload, null, 2) + '\n', 'utf-8');
+            await rename(tmpPath, this.filePath);
+        }
+        catch (err) {
+            throw new Error('Failed to save session metadata', { cause: err });
+        }
+    }
+}

package/server/dist/takeover.js

@@ -0,0 +1,172 @@
+import { readdir, readlink, readFile, realpath } from 'node:fs/promises';
+/**
+ * Check if `pid` is a descendant (child, grandchild, etc.) of any PID in `ancestorPids`
+ * by walking the ppid chain via /proc/<pid>/stat.
+ * A PID is not considered a descendant of itself.
+ */
+async function isDescendantOfAny(pid, ancestorPids) {
+    let current = pid;
+    // Walk up to 64 levels to avoid infinite loops on broken /proc data
+    for (let i = 0; i < 64; i++) {
+        let stat;
+        try {
+            stat = await readFile(`/proc/${current}/stat`, 'utf-8');
+        }
+        catch {
+            return false;
+        }
+        // /proc/<pid>/stat format: pid (comm) state ppid ...
+        // comm can contain spaces and parens, so find the last ')' first
+        const lastParen = stat.lastIndexOf(')');
+        if (lastParen === -1)
+            return false;
+        const afterComm = stat.slice(lastParen + 2); // skip ') '
+        const fields = afterComm.split(' ');
+        // fields[0] = state, fields[1] = ppid
+        const ppid = Number(fields[1]);
+        if (!Number.isInteger(ppid) || ppid <= 0)
+            return false;
+        if (ancestorPids.has(ppid))
+            return true;
+        // Reached init — not a descendant
+        if (ppid === 1)
+            return false;
+        current = ppid;
+    }
+    return false;
+}
+/**
+ * Find external pi processes whose working directory matches `folderPath`.
+ * Scans /proc to find processes running pi-coding-agent in the given folder.
+ *
+ * Excludes:
+ * - The current process (pimote server)
+ * - Descendants of the current process (sub-agents spawned by this server)
+ * - Descendants of any other pi process (sub-agents spawned by an external pi)
+ *
+ * Only "root" pi processes — those not parented by another pi process or this
+ * server — are returned as conflicts.
+ */
+export async function findExternalPiProcesses(folderPath) {
+    const myPid = process.pid;
+    let resolvedFolder;
+    try {
+        resolvedFolder = await realpath(folderPath);
+    }
+    catch {
+        return [];
+    }
+    let entries;
+    try {
+        entries = await readdir('/proc');
+    }
+    catch {
+        return [];
+    }
+    // First pass: collect all pi processes in this folder (excluding ourselves)
+    const allPiPids = [];
+    for (const entry of entries) {
+        const pid = Number(entry);
+        if (!Number.isInteger(pid) || pid <= 0 || pid === myPid)
+            continue;
+        try {
+            // Check cwd
+            const cwd = await readlink(`/proc/${pid}/cwd`);
+            let resolvedCwd;
+            try {
+                resolvedCwd = await realpath(`/proc/${pid}/cwd`);
+            }
+            catch {
+                resolvedCwd = cwd;
+            }
+            if (resolvedCwd !== resolvedFolder)
+                continue;
+            // Check cmdline to verify it's a pi process
+            const cmdlineRaw = await readFile(`/proc/${pid}/cmdline`, 'utf-8');
+            // cmdline uses null bytes as separators
+            const cmdline = cmdlineRaw.replace(/\0/g, ' ').trim();
+            if (!isPiProcess(cmdline))
+                continue;
+            allPiPids.push(pid);
+        }
+        catch (err) {
+            // ENOENT (process exited), EACCES (no permission) — skip
+            const code = err.code;
+            if (code === 'ENOENT' || code === 'EACCES')
+                continue;
+            // Other errors — skip too, but don't crash
+            continue;
+        }
+    }
+    if (allPiPids.length === 0)
+        return [];
+    // Second pass: filter out any pi process that is a descendant of
+    // this server or of another pi process in the set.
+    const ancestorPids = new Set([myPid, ...allPiPids]);
+    const rootPids = [];
+    for (const pid of allPiPids) {
+        if (await isDescendantOfAny(pid, ancestorPids))
+            continue;
+        rootPids.push(pid);
+    }
+    return rootPids;
+}
+/**
+ * Check if a cmdline string belongs to a pi-coding-agent process.
+ */
+function isPiProcess(cmdline) {
+    if (cmdline.includes('pi-coding-agent'))
+        return true;
+    // Check if any argv[0] ends with '/pi' or is exactly 'pi'
+    const parts = cmdline.split(/\s+/);
+    for (const part of parts) {
+        if (part === 'pi' || part.endsWith('/pi'))
+            return true;
+    }
+    return false;
+}
+/**
+ * Kill external pi processes in the given folder.
+ * Sends SIGTERM, waits 1 second, then SIGKILL if needed.
+ * Returns the number of processes killed.
+ */
+export async function killExternalPiProcesses(folderPath, targetPids) {
+    let pids = await findExternalPiProcesses(folderPath);
+    if (targetPids && targetPids.length > 0) {
+        pids = pids.filter((pid) => targetPids.includes(pid));
+    }
+    if (pids.length === 0)
+        return 0;
+    let killed = 0;
+    // Send SIGTERM to all
+    for (const pid of pids) {
+        try {
+            process.kill(pid, 'SIGTERM');
+            killed++;
+        }
+        catch {
+            // Process already gone
+        }
+    }
+    if (killed === 0)
+        return 0;
+    // Wait 1 second for graceful shutdown
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+    // Check survivors and SIGKILL
+    for (const pid of pids) {
+        try {
+            process.kill(pid, 0); // Check if alive
+            // Still alive — force kill
+            try {
+                process.kill(pid, 'SIGKILL');
+            }
+            catch {
+                // Already gone between check and kill
+            }
+        }
+        catch {
+            // Already dead — good
+        }
+    }
+    return killed;
+}