@infomity/remogent 0.0.0-stage → 0.2.0

package/dist/sessions.js

@@ -0,0 +1,389 @@
+import { stat } from "node:fs/promises";
+import { randomBytes } from "node:crypto";
+import { ProtocolError, } from "./protocol.js";
+import { autoTitle, customTitle } from "./title.js";
+class Session {
+    id;
+    engine;
+    cwd;
+    permissionMode;
+    status = "idle";
+    title;
+    createdAt;
+    updatedAt;
+    events = [];
+    viewers = new Set();
+    pending = new Map();
+    allowedForSession = new Set();
+    handle;
+    permSeq = 0;
+    /** Set by `SessionManager.delete`; a deleted session ignores any further engine events. */
+    deleted = false;
+    /** When the engine (or a viewer action) last produced an event; the stall watchdog measures silence from here. */
+    lastActivityAt = Date.now();
+    /** True while the last engine event was a tool call that has not reported completion. */
+    toolRunning = false;
+    /** When the watchdog last warned about the current silence (0 = not warned). */
+    lastStallWarnAt = 0;
+    constructor(id, engine, cwd, permissionMode, createdAt = Date.now()) {
+        this.id = id;
+        this.engine = engine;
+        this.cwd = cwd;
+        this.permissionMode = permissionMode;
+        this.createdAt = createdAt;
+        this.updatedAt = createdAt;
+    }
+    get lastSeq() {
+        return this.events.length ? this.events[this.events.length - 1].seq : 0;
+    }
+    info() {
+        return {
+            sessionId: this.id,
+            engine: this.engine,
+            cwd: this.cwd,
+            status: this.status,
+            ...(this.title ? { title: this.title } : {}),
+            createdAt: this.createdAt,
+            updatedAt: this.updatedAt,
+            lastSeq: this.lastSeq,
+        };
+    }
+}
+export class SessionManager {
+    store;
+    sessions = new Map();
+    adapters = new Map();
+    /** Viewers that want `session_updated` pushes (list screens). */
+    listeners = new Set();
+    saveTimer;
+    watchdog;
+    stallWarnMs;
+    stallToolMs;
+    stallRepeatMs;
+    /**
+     * With a store, sessions are written to disk (at most about once a second) and can be `restore`d after a restart.
+     * A watchdog warns viewers when an active turn goes silent (a hung engine looks exactly like a slow one otherwise).
+     */
+    constructor(store, wd = {}) {
+        this.store = store;
+        this.stallWarnMs = wd.stallWarnMs ?? 60_000;
+        this.stallToolMs = wd.stallToolMs ?? 300_000;
+        this.stallRepeatMs = wd.stallRepeatMs ?? 300_000;
+        this.watchdog = setInterval(() => this.checkStalls(), wd.checkMs ?? 5_000);
+        this.watchdog.unref();
+    }
+    registerAdapter(a) {
+        this.adapters.set(a.engine, a);
+    }
+    /**
+     * Loads persisted sessions. Call after the adapters are registered and before serving clients.
+     * - Claude (resumable) sessions come back idle; the CLI is spawned with `--resume` on the next prompt.
+     * - Sessions that were mid-turn get an error + cancelled `turn_end`; pending approvals are gone (denied), and
+     *   "allow for session" grants are deliberately NOT restored.
+     * - Sessions that cannot be resumed (engine missing/not resumable, no engine conversation id) are read-only history.
+     * - Sessions that never got a prompt are dropped.
+     */
+    async restore() {
+        if (!this.store)
+            return 0;
+        let n = 0;
+        for (const p of this.store.load()) {
+            if (!p.events.some((e) => e.event.kind === "user_message"))
+                continue;
+            const s = new Session(p.id, p.engine, p.cwd, p.permissionMode, p.createdAt);
+            s.updatedAt = p.updatedAt;
+            if (p.title)
+                s.title = p.title;
+            s.events = p.events;
+            s.permSeq = p.permSeq;
+            s.status = p.status;
+            const seqBefore = s.lastSeq;
+            const adapter = this.adapters.get(p.engine);
+            let resumed = false;
+            if (p.status !== "completed" && adapter?.resumable && p.engineSessionId) {
+                try {
+                    s.handle = await adapter.start({ cwd: p.cwd, permissionMode: p.permissionMode, resumeId: p.engineSessionId }, this.sinkFor(s));
+                    resumed = true;
+                }
+                catch {
+                    /* falls through to read-only history */
+                }
+            }
+            if (p.status === "active" && resumed) {
+                this.emit(s, { kind: "error", message: "The host restarted while this turn was running." });
+                this.emit(s, { kind: "turn_end", stopReason: "cancelled" });
+            }
+            const want = resumed ? "idle" : "completed";
+            if (s.status !== want || lastStatusEvent(s) !== want)
+                this.setStatus(s, want);
+            // Restoring is not activity: keep the original ordering unless we had to append events.
+            if (s.lastSeq === seqBefore)
+                s.updatedAt = p.updatedAt;
+            this.sessions.set(s.id, s);
+            n++;
+        }
+        return n;
+    }
+    /** Writes the store now (used on shutdown). */
+    flush() {
+        if (this.saveTimer)
+            clearTimeout(this.saveTimer);
+        this.saveTimer = undefined;
+        this.store?.save([...this.sessions.values()].map(toPersisted));
+    }
+    scheduleSave() {
+        if (!this.store || this.saveTimer)
+            return;
+        this.saveTimer = setTimeout(() => this.flush(), 1000);
+        this.saveTimer.unref();
+    }
+    engines() {
+        return [...this.adapters.keys()];
+    }
+    addListener(v) {
+        this.listeners.add(v);
+    }
+    /** Call when a client socket closes. */
+    viewerGone(v) {
+        this.listeners.delete(v);
+        for (const s of this.sessions.values())
+            s.viewers.delete(v);
+    }
+    list() {
+        return [...this.sessions.values()].map((s) => s.info()).sort((a, b) => b.updatedAt - a.updatedAt);
+    }
+    get(sessionId, reqId) {
+        const s = this.sessions.get(sessionId);
+        if (!s)
+            throw new ProtocolError("unknown_session", `unknown session "${sessionId}"`, reqId);
+        return s;
+    }
+    async create(engine, cwd, permissionMode, reqId) {
+        const adapter = this.adapters.get(engine);
+        if (!adapter)
+            throw new ProtocolError("engine_unavailable", `engine "${engine}" is not available on this host`, reqId);
+        try {
+            if (!(await stat(cwd)).isDirectory())
+                throw new Error("not a directory");
+        }
+        catch {
+            throw new ProtocolError("cwd_denied", "cwd does not exist or is not a directory", reqId);
+        }
+        const s = new Session("s" + randomBytes(6).toString("hex"), engine, cwd, permissionMode);
+        this.sessions.set(s.id, s);
+        try {
+            s.handle = await adapter.start({ cwd, permissionMode }, this.sinkFor(s));
+        }
+        catch (e) {
+            this.sessions.delete(s.id);
+            throw new ProtocolError("engine_failed", e instanceof Error ? e.message : String(e), reqId);
+        }
+        this.pushUpdated(s);
+        return s.info();
+    }
+    attach(sessionId, v, afterSeq, reqId) {
+        const s = this.get(sessionId, reqId);
+        const replay = s.events.filter((e) => e.seq > afterSeq);
+        const fromSeq = replay.length ? replay[0].seq : s.lastSeq + 1;
+        v.send({ type: "session_attached", reqId, sessionId, fromSeq, toSeq: s.lastSeq });
+        for (const e of replay) {
+            v.send({ type: "session_event", sessionId, seq: e.seq, ...(e.ts !== undefined ? { ts: e.ts } : {}), event: e.event, replay: true });
+        }
+        for (const p of s.pending.values())
+            v.send({ type: "permission_request", sessionId, ...stripKind(p.body) });
+        s.viewers.add(v);
+    }
+    detach(sessionId, v) {
+        this.get(sessionId).viewers.delete(v);
+    }
+    /** Starts a turn; returns once it is accepted (output arrives as events). */
+    prompt(sessionId, text, reqId) {
+        const s = this.get(sessionId, reqId);
+        if (s.status === "completed" || !s.handle)
+            throw new ProtocolError("invalid_message", "session is closed", reqId);
+        if (s.status === "active")
+            throw new ProtocolError("invalid_message", "a turn is already running", reqId);
+        if (!s.title)
+            s.title = autoTitle(text);
+        this.setStatus(s, "active");
+        this.emit(s, { kind: "user_message", text });
+        s.handle.prompt(text).then(() => {
+            if (s.status === "active")
+                this.setStatus(s, "idle");
+        }, (e) => {
+            this.emit(s, { kind: "error", message: e instanceof Error ? e.message : String(e) });
+            this.emit(s, { kind: "turn_end", stopReason: "error" });
+            if (s.status === "active")
+                this.setStatus(s, "idle");
+        });
+    }
+    cancel(sessionId) {
+        const s = this.get(sessionId);
+        this.denyAllPending(s);
+        s.handle?.cancel();
+    }
+    close(sessionId, reqId) {
+        const s = this.get(sessionId, reqId);
+        this.denyAllPending(s);
+        s.handle?.close();
+        this.setStatus(s, "completed");
+    }
+    /**
+     * Removes a chat for good: stops the engine if it still runs, drops the transcript from memory and from the
+     * store, and tells every connected client with `session_deleted`. Unlike `close`, nothing stays readable.
+     */
+    delete(sessionId, reqId) {
+        const s = this.get(sessionId, reqId);
+        this.denyAllPending(s);
+        s.deleted = true;
+        s.handle?.close();
+        this.sessions.delete(sessionId);
+        const msg = { type: "session_deleted", sessionId };
+        const told = new Set([...this.listeners, ...s.viewers]);
+        for (const v of told)
+            v.send(msg);
+        s.viewers.clear();
+        this.scheduleSave();
+    }
+    /**
+     * Sets the chat title (works for finished chats too). An empty title resets to the automatic one derived from the
+     * first prompt. Pushes `session_updated` to list listeners; does not touch `updatedAt` so the drawer order stays put.
+     */
+    rename(sessionId, title, reqId) {
+        const s = this.get(sessionId, reqId);
+        const next = customTitle(title);
+        if (next)
+            s.title = next;
+        else {
+            const first = s.events.find((e) => e.event.kind === "user_message")?.event;
+            const auto = first && first.kind === "user_message" ? autoTitle(first.text) : "";
+            if (auto)
+                s.title = auto;
+            else
+                delete s.title;
+        }
+        this.pushUpdated(s);
+        this.scheduleSave();
+    }
+    respond(sessionId, requestId, decision) {
+        const s = this.get(sessionId);
+        const p = s.pending.get(requestId);
+        if (!p)
+            throw new ProtocolError("unknown_request", `no pending request "${requestId}"`);
+        s.pending.delete(requestId);
+        if (decision === "allow_session")
+            s.allowedForSession.add(p.toolKey);
+        this.emit(s, { kind: "permission_resolved", requestId, decision });
+        p.resolve(decision);
+    }
+    closeAll() {
+        if (this.watchdog)
+            clearInterval(this.watchdog);
+        this.watchdog = undefined;
+        for (const s of this.sessions.values()) {
+            this.denyAllPending(s);
+            s.handle?.close();
+        }
+        this.flush();
+    }
+    // ---- internals ----
+    sinkFor(s) {
+        return {
+            emit: (event) => this.emit(s, event),
+            requestPermission: (req) => {
+                const toolKey = `${req.tool}:${req.risk}`;
+                if (s.allowedForSession.has(toolKey))
+                    return Promise.resolve("allow_session");
+                const requestId = `p${++s.permSeq}`;
+                const body = { kind: "permission_request", requestId, ...req };
+                return new Promise((resolve) => {
+                    s.pending.set(requestId, { body, toolKey, resolve });
+                    this.emit(s, body);
+                    for (const v of s.viewers)
+                        v.send({ type: "permission_request", sessionId: s.id, ...stripKind(body) });
+                });
+            },
+        };
+    }
+    denyAllPending(s) {
+        for (const [requestId, p] of s.pending) {
+            this.emit(s, { kind: "permission_resolved", requestId, decision: "deny" });
+            p.resolve("deny");
+        }
+        s.pending.clear();
+    }
+    emit(s, event, watchdogNotice = false) {
+        if (s.deleted)
+            return; // a late engine event (exit, error) must not resurrect a deleted chat
+        const seq = s.lastSeq + 1;
+        const ts = Date.now();
+        s.events.push({ seq, event, ts });
+        s.updatedAt = ts;
+        if (!watchdogNotice) {
+            // Any real event ends the silence (the watchdog's own warning must not reset it).
+            s.lastActivityAt = ts;
+            s.lastStallWarnAt = 0;
+            s.toolRunning = event.kind === "tool_call" || (event.kind === "tool_call_update" && event.status === "running");
+        }
+        if (event.kind === "status")
+            s.status = event.status;
+        for (const v of s.viewers)
+            v.send({ type: "session_event", sessionId: s.id, seq, ts, event });
+        this.pushUpdated(s);
+        this.scheduleSave();
+    }
+    /** Warns viewers about active turns that have produced nothing for too long. Quiet while an approval is pending. */
+    checkStalls() {
+        const now = Date.now();
+        for (const s of this.sessions.values()) {
+            if (s.deleted || s.status !== "active" || !s.handle || s.pending.size > 0)
+                continue;
+            const silent = now - s.lastActivityAt;
+            if (silent < (s.toolRunning ? this.stallToolMs : this.stallWarnMs))
+                continue;
+            if (s.lastStallWarnAt && now - s.lastStallWarnAt < this.stallRepeatMs)
+                continue;
+            s.lastStallWarnAt = now;
+            const who = s.engine === "gemini" ? "Gemini" : s.engine === "codex" ? "Codex" : "Claude";
+            const how = silent >= 120_000 ? `${Math.round(silent / 60_000)} min` : `${Math.round(silent / 1000)} s`;
+            const what = s.toolRunning ? "a tool call is still running" : `${who} may be stuck waiting on the model API`;
+            this.emit(s, { kind: "error", message: `No output from ${who} for ${how}: ${what}. Tap Stop and resend if it does not recover.` }, true);
+        }
+    }
+    setStatus(s, status) {
+        this.emit(s, { kind: "status", status });
+    }
+    pushUpdated(s) {
+        for (const v of this.listeners)
+            v.send({ type: "session_updated", session: s.info() });
+    }
+}
+function stripKind(o) {
+    const { kind: _kind, ...rest } = o;
+    return rest;
+}
+function lastStatusEvent(s) {
+    for (let i = s.events.length - 1; i >= 0; i--) {
+        const ev = s.events[i].event;
+        if (ev.kind === "status")
+            return ev.status;
+    }
+    return undefined;
+}
+function toPersisted(s) {
+    const engineSessionId = s.handle?.engineSessionId?.();
+    return {
+        id: s.id,
+        engine: s.engine,
+        cwd: s.cwd,
+        permissionMode: s.permissionMode,
+        ...(s.title ? { title: s.title } : {}),
+        createdAt: s.createdAt,
+        updatedAt: s.updatedAt,
+        status: s.status,
+        ...(engineSessionId ? { engineSessionId } : {}),
+        permSeq: s.permSeq,
+        events: s.events,
+    };
+}
+//# sourceMappingURL=sessions.js.map

package/dist/store.js

@@ -0,0 +1,103 @@
+import { chmodSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { REMOGENT_DIR } from "./identity.js";
+/** Where session transcripts live on the host (next to identity.json). Plain JSON, owner-only where the OS supports it. */
+export const SESSIONS_FILE = join(REMOGENT_DIR, "sessions.json");
+const FILE_VERSION = 1;
+/** Sessions untouched for this long are dropped when the daemon loads them. */
+const MAX_AGE_MS = 14 * 24 * 60 * 60 * 1000;
+/** At most this many sessions are kept (most recently updated first). */
+const MAX_SESSIONS = 100;
+/** Approximate serialized size kept per session; the oldest events are trimmed first (seq numbers stay intact). */
+const MAX_SESSION_BYTES = 2 * 1024 * 1024;
+const isObj = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+function valid(p) {
+    if (!isObj(p))
+        return false;
+    return (typeof p["id"] === "string" &&
+        (p["engine"] === "claude" || p["engine"] === "gemini" || p["engine"] === "codex") &&
+        typeof p["cwd"] === "string" &&
+        typeof p["permissionMode"] === "string" &&
+        typeof p["createdAt"] === "number" &&
+        typeof p["updatedAt"] === "number" &&
+        typeof p["status"] === "string" &&
+        Array.isArray(p["events"]) &&
+        p["events"].every((e) => isObj(e) && typeof e["seq"] === "number" && isObj(e["event"])));
+}
+/** Keeps the newest events of one session within the byte budget. */
+function trimEvents(events) {
+    let bytes = 0;
+    let from = events.length;
+    while (from > 0) {
+        bytes += JSON.stringify(events[from - 1]).length;
+        if (bytes > MAX_SESSION_BYTES)
+            break;
+        from--;
+    }
+    return from === 0 ? events : events.slice(from);
+}
+export class SessionStore {
+    file;
+    log;
+    constructor(file = SESSIONS_FILE, log = () => { }) {
+        this.file = file;
+        this.log = log;
+    }
+    /** Never throws: a missing file is an empty store, a corrupt one is set aside and ignored. */
+    load(now = Date.now()) {
+        let text;
+        try {
+            text = readFileSync(this.file, "utf8");
+        }
+        catch {
+            return [];
+        }
+        try {
+            const raw = JSON.parse(text);
+            if (!isObj(raw) || raw["version"] !== FILE_VERSION || !Array.isArray(raw["sessions"]))
+                throw new Error("unrecognized format");
+            return raw["sessions"]
+                .filter(valid)
+                .filter((s) => now - s.updatedAt < MAX_AGE_MS)
+                .sort((a, b) => b.updatedAt - a.updatedAt)
+                .slice(0, MAX_SESSIONS);
+        }
+        catch (e) {
+            const aside = `${this.file}.corrupt-${now}`;
+            try {
+                renameSync(this.file, aside);
+            }
+            catch {
+                /* nothing more we can do */
+            }
+            this.log(`sessions file unreadable (${e instanceof Error ? e.message : String(e)}); set aside as ${aside}`);
+            return [];
+        }
+    }
+    /** Atomic (temp file + rename) so a crash mid-write never leaves a half-written store. Never throws. */
+    save(sessions) {
+        const body = {
+            version: FILE_VERSION,
+            sessions: [...sessions]
+                .sort((a, b) => b.updatedAt - a.updatedAt)
+                .slice(0, MAX_SESSIONS)
+                .map((s) => ({ ...s, events: trimEvents(s.events) })),
+        };
+        const tmp = `${this.file}.tmp`;
+        try {
+            mkdirSync(dirname(this.file), { recursive: true });
+            writeFileSync(tmp, JSON.stringify(body), { encoding: "utf8", mode: 0o600 });
+            try {
+                chmodSync(tmp, 0o600);
+            }
+            catch {
+                /* not supported on this platform */
+            }
+            renameSync(tmp, this.file);
+        }
+        catch (e) {
+            this.log(`could not save sessions: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    }
+}
+//# sourceMappingURL=store.js.map

package/dist/title.js

@@ -0,0 +1,43 @@
+/**
+ * Chat titles. Neither engine sends one (probed 2026-11-14: Claude Code stream-json only emits
+ * `system:session_title_changed` after an explicit `/rename`; Gemini ACP has no title channel), so the host derives
+ * a title from the first prompt and lets the owner rename it.
+ */
+const MAX_AUTO = 60;
+export const MAX_CUSTOM = 80;
+/** Windows (`C:\a\b.ts`, `E:/a/b`), relative (`./a`, `..\a`, `~/a`) and absolute multi-segment POSIX paths. */
+const PATH_RE = /(?<![\w./\\:-])(?:[A-Za-z]:[\\/]|\.{1,2}[\\/]|~[\\/]|\/(?=[^\s/]+\/))[^\s"'`<>|]*/g;
+function clip(s, max) {
+    if (s.length <= max)
+        return s;
+    const cut = s.slice(0, max - 1);
+    const sp = cut.lastIndexOf(" ");
+    return (sp > max * 0.5 ? cut.slice(0, sp) : cut).trimEnd() + "\u2026";
+}
+function lastSegment(p) {
+    const trimmed = p.replace(/[\\/]+$/, "").replace(/[.,;:!?)\]]+$/, "");
+    const seg = trimmed.split(/[\\/]/).pop() ?? "";
+    return seg && seg !== "." && seg !== ".." && seg !== "~" ? seg : "";
+}
+/**
+ * First-prompt fallback title: collapses whitespace, drops a leading slash command (`/init fix the build` becomes
+ * `fix the build`) and shortens file paths to their last segment (`fix E:\a\b\foo.ts` becomes `fix foo.ts`).
+ * Never returns an empty string for non-empty input: if cleaning removes everything the trimmed original is used.
+ */
+export function autoTitle(raw, max = MAX_AUTO) {
+    const flat = raw.replace(/\s+/g, " ").trim();
+    if (!flat)
+        return "";
+    let t = flat.replace(/^(?:\/[\w:.-]+\s*)+/, "");
+    t = t.replace(PATH_RE, (m) => lastSegment(m));
+    t = t
+        .replace(/^[#>*\-\s`"']+/, "") // markdown/quote leaders
+        .replace(/\s+/g, " ")
+        .trim();
+    return clip(t || flat, max);
+}
+/** Owner-chosen title: whitespace collapsed and capped. Empty input returns "" (meaning "reset to automatic"). */
+export function customTitle(raw) {
+    return clip(raw.replace(/\s+/g, " ").trim(), MAX_CUSTOM);
+}
+//# sourceMappingURL=title.js.map

package/package.json

@@ -1,6 +1,56 @@
 {
   "name": "@infomity/remogent",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.2.0",
+  "description": "Remogent host: drive Claude Code, Gemini CLI and Codex CLI on your PC from the Remogent Android app. No cloud relay, no account.",
+  "license": "Apache-2.0",
+  "type": "module",
+  "keywords": ["remogent", "claude-code", "gemini-cli", "codex", "remote", "android", "ai-agent", "cli"],
+  "homepage": "https://infomity.github.io/remogent/",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/infomity/Remogent.git",
+    "directory": "companion"
+  },
+  "bugs": {
+    "url": "https://github.com/infomity/Remogent/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "bin": {
+    "remogent": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "!dist/**/*.map",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "dev": "tsx src/index.ts",
+    "start": "node dist/index.js start",
+    "setup": "npm install && npm run build && node dist/index.js setup",
+    "doctor": "node dist/index.js doctor",
+    "pair": "node dist/index.js pair",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "prepack": "node scripts/prepack.mjs",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "bonjour-service": "^1.3.0",
+    "qrcode-terminal": "^0.12.0",
+    "selfsigned": "^2.4.1",
+    "ws": "^8.18.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "@types/qrcode-terminal": "^0.12.2",
+    "@types/ws": "^8.5.12",
+    "tsx": "^4.19.0",
+    "typescript": "^5.6.0"
+  }
+}