remcodex 0.1.0-beta.1

package/dist/server/src/services/event-store.js

@@ -0,0 +1,328 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventStore = void 0;
+const node_events_1 = require("node:events");
+const ids_1 = require("../utils/ids");
+class EventStore {
+    db;
+    emitter = new node_events_1.EventEmitter();
+    latestQuotaCache = new Map();
+    constructor(db) {
+        this.db = db;
+    }
+    append(sessionId, input) {
+        const seq = this.nextSeq(sessionId);
+        const id = input.id?.trim() || (0, ids_1.createId)("evt");
+        const timestamp = input.timestamp?.trim() || new Date().toISOString();
+        const payloadJson = JSON.stringify(input.payload ?? {});
+        const stream = this.normalizeStream(input.stream);
+        this.db
+            .prepare(`
+          INSERT INTO session_events (
+            id,
+            session_id,
+            turn_id,
+            seq,
+            event_type,
+            message_id,
+            call_id,
+            request_id,
+            phase,
+            stream,
+            payload_json,
+            created_at
+          )
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        `)
+            .run(id, sessionId, input.turnId, seq, input.type, input.messageId, input.callId, input.requestId, input.phase, stream, payloadJson, timestamp);
+        const row = this.db
+            .prepare(`
+          SELECT
+            id,
+            session_id,
+            turn_id,
+            seq,
+            event_type,
+            message_id,
+            call_id,
+            request_id,
+            phase,
+            stream,
+            payload_json,
+            created_at
+          FROM session_events
+          WHERE id = ?
+        `)
+            .get(id);
+        const event = this.toPayload(row);
+        this.captureLatestQuota(sessionId, event);
+        this.emitter.emit(this.channel(sessionId), event);
+        return event;
+    }
+    list(sessionId, options = {}) {
+        const safeLimit = Math.max(1, Math.min(options.limit ?? 200, 200));
+        const after = Math.max(0, options.after ?? 0);
+        const before = Math.max(0, options.before ?? 0);
+        if (before > 0) {
+            const rows = this.db
+                .prepare(`
+            SELECT
+              id,
+              session_id,
+              turn_id,
+              seq,
+              event_type,
+              message_id,
+              call_id,
+              request_id,
+              phase,
+              stream,
+              payload_json,
+              created_at
+            FROM session_events
+            WHERE session_id = ? AND seq < ?
+            ORDER BY seq DESC
+            LIMIT ?
+          `)
+                .all(sessionId, before, safeLimit + 1);
+            const hasMoreBefore = rows.length > safeLimit;
+            const pageRows = rows.slice(0, safeLimit).reverse();
+            return {
+                items: pageRows.map((row) => this.toPayload(row)),
+                nextCursor: pageRows.length > 0 ? pageRows[pageRows.length - 1].seq : after,
+                beforeCursor: pageRows.length > 0 ? pageRows[0].seq : before,
+                hasMoreBefore,
+            };
+        }
+        if (after > 0) {
+            const rows = this.db
+                .prepare(`
+            SELECT
+              id,
+              session_id,
+              turn_id,
+              seq,
+              event_type,
+              message_id,
+              call_id,
+              request_id,
+              phase,
+              stream,
+              payload_json,
+              created_at
+            FROM session_events
+            WHERE session_id = ? AND seq > ?
+            ORDER BY seq ASC
+            LIMIT ?
+          `)
+                .all(sessionId, after, safeLimit);
+            return {
+                items: rows.map((row) => this.toPayload(row)),
+                nextCursor: rows.length > 0 ? rows[rows.length - 1].seq : after,
+                beforeCursor: rows.length > 0 ? rows[0].seq : 0,
+                hasMoreBefore: rows.length > 0 ? rows[0].seq > 1 : false,
+            };
+        }
+        const rows = this.db
+            .prepare(`
+          SELECT
+            id,
+            session_id,
+            turn_id,
+            seq,
+            event_type,
+            message_id,
+            call_id,
+            request_id,
+            phase,
+            stream,
+            payload_json,
+            created_at
+          FROM session_events
+          WHERE session_id = ?
+          ORDER BY seq DESC
+          LIMIT ?
+        `)
+            .all(sessionId, safeLimit + 1);
+        const hasMoreBefore = rows.length > safeLimit;
+        const pageRows = rows.slice(0, safeLimit).reverse();
+        return {
+            items: pageRows.map((row) => this.toPayload(row)),
+            nextCursor: pageRows.length > 0 ? pageRows[pageRows.length - 1].seq : after,
+            beforeCursor: pageRows.length > 0 ? pageRows[0].seq : 0,
+            hasMoreBefore,
+        };
+    }
+    listAll(sessionId) {
+        const rows = this.db
+            .prepare(`
+          SELECT
+            id,
+            session_id,
+            turn_id,
+            seq,
+            event_type,
+            message_id,
+            call_id,
+            request_id,
+            phase,
+            stream,
+            payload_json,
+            created_at
+          FROM session_events
+          WHERE session_id = ?
+          ORDER BY seq ASC
+        `)
+            .all(sessionId);
+        return rows.map((row) => this.toPayload(row));
+    }
+    latestQuota(sessionId) {
+        const cached = this.latestQuotaCache.get(sessionId);
+        if (cached) {
+            return cached;
+        }
+        const rows = this.db
+            .prepare(`
+          SELECT payload_json
+          FROM session_events
+          WHERE session_id = ?
+            AND event_type = 'token_count'
+          ORDER BY seq DESC
+        `)
+            .all(sessionId);
+        for (const row of rows) {
+            const payload = this.tryParse(row.payload_json ?? null);
+            if (payload && this.hasUsableQuota(payload)) {
+                this.latestQuotaCache.set(sessionId, payload);
+                return payload;
+            }
+        }
+        return null;
+    }
+    latestPendingApproval(sessionId) {
+        const rows = this.db
+            .prepare(`
+          SELECT event_type, request_id, payload_json, seq
+          FROM session_events
+          WHERE session_id = ?
+            AND event_type IN ('approval.requested', 'approval.resolved')
+          ORDER BY seq ASC
+        `)
+            .all(sessionId);
+        if (rows.length === 0) {
+            return null;
+        }
+        const pending = new Map();
+        for (const row of rows) {
+            if (row.event_type === "approval.requested") {
+                const payload = this.tryParse(row.payload_json);
+                const requestId = row.request_id || payload?.requestId || "";
+                if (requestId) {
+                    pending.set(requestId, {
+                        ...payload,
+                        requestId,
+                    });
+                }
+                continue;
+            }
+            const payload = this.tryParse(row.payload_json);
+            const requestId = row.request_id || payload?.requestId || "";
+            if (requestId) {
+                pending.delete(requestId);
+            }
+        }
+        const unresolved = [...pending.values()].sort((a, b) => String(a.createdAt || "").localeCompare(String(b.createdAt || "")));
+        return unresolved[0] ?? null;
+    }
+    subscribe(sessionId, listener) {
+        const channel = this.channel(sessionId);
+        this.emitter.on(channel, listener);
+        return () => {
+            this.emitter.off(channel, listener);
+        };
+    }
+    nextSeq(sessionId) {
+        const row = this.db
+            .prepare(`
+          SELECT COALESCE(MAX(seq), 0) AS current_seq
+          FROM session_events
+          WHERE session_id = ?
+        `)
+            .get(sessionId);
+        return row.current_seq + 1;
+    }
+    toPayload(row) {
+        return {
+            id: row.id,
+            sessionId: row.session_id,
+            type: row.event_type,
+            seq: row.seq,
+            timestamp: row.created_at,
+            turnId: row.turn_id,
+            messageId: row.message_id,
+            callId: row.call_id,
+            requestId: row.request_id,
+            phase: row.phase,
+            stream: this.normalizeStream(row.stream),
+            payload: this.tryParse(row.payload_json) ?? {},
+        };
+    }
+    tryParse(raw) {
+        if (!raw) {
+            return null;
+        }
+        try {
+            return JSON.parse(raw);
+        }
+        catch {
+            return null;
+        }
+    }
+    normalizeStream(stream) {
+        switch (stream) {
+            case "stdout":
+            case "stderr":
+                return stream;
+            default:
+                return null;
+        }
+    }
+    channel(sessionId) {
+        return `session:${sessionId}`;
+    }
+    captureLatestQuota(sessionId, event) {
+        if (event.type !== "token_count") {
+            return;
+        }
+        const payload = event.payload;
+        if (payload && this.hasUsableQuota(payload)) {
+            this.latestQuotaCache.set(sessionId, payload);
+        }
+    }
+    hasUsableQuota(payload) {
+        const rateLimits = payload.rateLimits && typeof payload.rateLimits === "object"
+            ? payload.rateLimits
+            : {};
+        const primary = rateLimits.primary && typeof rateLimits.primary === "object"
+            ? rateLimits.primary
+            : {};
+        const secondary = rateLimits.secondary && typeof rateLimits.secondary === "object"
+            ? rateLimits.secondary
+            : {};
+        return (this.readQuotaField(primary.used_percent) != null ||
+            this.readQuotaField(primary.resets_at) != null ||
+            this.readQuotaField(secondary.used_percent) != null ||
+            this.readQuotaField(secondary.resets_at) != null);
+    }
+    readQuotaField(input) {
+        if (typeof input === "number" && Number.isFinite(input)) {
+            return input;
+        }
+        if (typeof input === "string" && input.trim()) {
+            const parsed = Number.parseFloat(input);
+            return Number.isFinite(parsed) ? parsed : null;
+        }
+        return null;
+    }
+}
+exports.EventStore = EventStore;

package/dist/server/src/services/project-manager.js

@@ -0,0 +1,130 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectManager = void 0;
+const node_fs_1 = require("node:fs");
+const node_os_1 = require("node:os");
+const node_path_1 = __importDefault(require("node:path"));
+const errors_1 = require("../utils/errors");
+const ids_1 = require("../utils/ids");
+class ProjectManager {
+    db;
+    allowedRoots;
+    constructor(db, projectRootsEnv, repoRoot) {
+        this.db = db;
+        this.allowedRoots = (projectRootsEnv ?? (0, node_os_1.homedir)())
+            .split(",")
+            .map((item) => item.trim())
+            .filter(Boolean)
+            .map((item) => node_path_1.default.resolve(item));
+    }
+    listProjects() {
+        return this.db
+            .prepare(`
+          SELECT id, name, path, created_at
+          FROM projects
+          ORDER BY created_at DESC
+        `)
+            .all();
+    }
+    getProject(projectId) {
+        return (this.db
+            .prepare(`
+            SELECT id, name, path, created_at
+            FROM projects
+            WHERE id = ?
+          `)
+            .get(projectId) ?? null);
+    }
+    createProject(input) {
+        const name = input.name.trim();
+        const resolvedPath = node_path_1.default.resolve(input.path.trim());
+        if (!name) {
+            throw new errors_1.AppError(400, "Project name is required.");
+        }
+        if (!input.path.trim()) {
+            throw new errors_1.AppError(400, "Project path is required.");
+        }
+        if (!(0, node_fs_1.existsSync)(resolvedPath) && input.createMissing) {
+            (0, node_fs_1.mkdirSync)(resolvedPath, { recursive: true });
+        }
+        if (!(0, node_fs_1.existsSync)(resolvedPath) || !(0, node_fs_1.statSync)(resolvedPath).isDirectory()) {
+            throw new errors_1.AppError(400, "Project path does not exist or is not a directory.");
+        }
+        if (!this.isAllowed(resolvedPath)) {
+            throw new errors_1.AppError(400, `Project path is outside allowed roots: ${this.allowedRoots.join(", ")}`);
+        }
+        const duplicated = this.db
+            .prepare(`
+          SELECT id
+          FROM projects
+          WHERE path = ?
+        `)
+            .get(resolvedPath);
+        if (duplicated) {
+            throw new errors_1.AppError(409, "Project path is already registered.");
+        }
+        const project = {
+            id: (0, ids_1.createId)("proj"),
+            name,
+            path: resolvedPath,
+            created_at: new Date().toISOString(),
+        };
+        this.db
+            .prepare(`
+          INSERT INTO projects (id, name, path, created_at)
+          VALUES (?, ?, ?, ?)
+        `)
+            .run(project.id, project.name, project.path, project.created_at);
+        return project;
+    }
+    listAllowedRoots() {
+        return [...this.allowedRoots];
+    }
+    browseDirectories(targetPath) {
+        const rawTarget = String(targetPath || "").trim();
+        if (!rawTarget) {
+            return {
+                currentPath: null,
+                parentPath: null,
+                items: this.allowedRoots.map((root) => ({
+                    name: node_path_1.default.basename(root) || root,
+                    path: root,
+                })),
+            };
+        }
+        const resolvedPath = node_path_1.default.resolve(rawTarget);
+        const root = this.findAllowedRoot(resolvedPath);
+        if (!root) {
+            throw new errors_1.AppError(400, `Project path is outside allowed roots: ${this.allowedRoots.join(", ")}`);
+        }
+        if (!(0, node_fs_1.existsSync)(resolvedPath) || !(0, node_fs_1.statSync)(resolvedPath).isDirectory()) {
+            throw new errors_1.AppError(400, "Project path does not exist or is not a directory.");
+        }
+        const items = (0, node_fs_1.readdirSync)(resolvedPath, { withFileTypes: true })
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => ({
+            name: entry.name,
+            path: node_path_1.default.join(resolvedPath, entry.name),
+        }))
+            .sort((left, right) => left.name.localeCompare(right.name, undefined, { sensitivity: "base" }));
+        const parentPath = resolvedPath === root ? null : node_path_1.default.dirname(resolvedPath);
+        return {
+            currentPath: resolvedPath,
+            parentPath,
+            items,
+        };
+    }
+    isAllowed(targetPath) {
+        return Boolean(this.findAllowedRoot(targetPath));
+    }
+    findAllowedRoot(targetPath) {
+        return (this.allowedRoots.find((root) => {
+            const relative = node_path_1.default.relative(root, targetPath);
+            return relative === "" || (!relative.startsWith("..") && !node_path_1.default.isAbsolute(relative));
+        }) ?? null);
+    }
+}
+exports.ProjectManager = ProjectManager;

package/dist/server/src/services/pty-runner.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PtyRunner = void 0;
+const node_pty_1 = require("node-pty");
+const node_pty_2 = require("../utils/node-pty");
+class PtyRunner {
+    command;
+    cwd;
+    process = null;
+    dataListeners = new Set();
+    exitListeners = new Set();
+    stopTimer = null;
+    constructor(command, cwd) {
+        this.command = command;
+        this.cwd = cwd;
+    }
+    start() {
+        (0, node_pty_2.ensureNodePtyHelperExecutable)();
+        const shell = process.env.SHELL ?? "/bin/zsh";
+        this.process = (0, node_pty_1.spawn)(shell, ["-lc", this.command], {
+            cwd: this.cwd,
+            cols: 120,
+            rows: 30,
+            name: "xterm-256color",
+            env: {
+                ...process.env,
+                TERM: "xterm-256color",
+            },
+        });
+        this.process.onData((chunk) => {
+            this.dataListeners.forEach((listener) => listener(chunk));
+        });
+        this.process.onExit(({ exitCode }) => {
+            if (this.stopTimer) {
+                clearTimeout(this.stopTimer);
+                this.stopTimer = null;
+            }
+            this.process = null;
+            this.exitListeners.forEach((listener) => listener(exitCode));
+        });
+        return this.process.pid;
+    }
+    write(input) {
+        this.process?.write(input);
+    }
+    stop() {
+        if (!this.process) {
+            return;
+        }
+        this.process.write("\u0003");
+        this.stopTimer = setTimeout(() => {
+            this.process?.kill();
+        }, 1500);
+        this.stopTimer.unref();
+    }
+    onData(listener) {
+        this.dataListeners.add(listener);
+        return () => {
+            this.dataListeners.delete(listener);
+        };
+    }
+    onExit(listener) {
+        this.exitListeners.add(listener);
+        return () => {
+            this.exitListeners.delete(listener);
+        };
+    }
+    isAlive() {
+        return this.process !== null;
+    }
+}
+exports.PtyRunner = PtyRunner;