auvrynt 1.0.2 → 1.0.5

package/dist/workspace/workspace-store.js

@@ -0,0 +1,219 @@
+import { copyFileSync } from "node:fs";
+import { join } from "node:path";
+import { eq } from "drizzle-orm";
+import { databasePath, openDatabase } from "../db/client.js";
+import { workspaceSessions, } from "../db/schema.js";
+const WORKSPACE_SESSION_TTL_MS = 30 * 24 * 60 * 60 * 1000;
+const MAX_PERSISTED_WORKSPACE_SESSIONS = 512;
+export class SqliteWorkspaceStore {
+    database;
+    stateDir;
+    constructor(stateDir) {
+        this.database = openDatabase(stateDir);
+        this.stateDir = stateDir;
+        this.migrate();
+        this.pruneStaleSessions();
+    }
+    createSession(input) {
+        const now = new Date().toISOString();
+        const session = {
+            id: input.id,
+            root: input.root,
+            status: "active",
+            mode: input.mode ?? "checkout",
+            sourceRoot: input.sourceRoot,
+            baseRef: input.baseRef,
+            baseSha: input.baseSha,
+            managed: input.managed ?? false,
+            createdAt: now,
+            lastUsedAt: now,
+        };
+        this.database.db
+            .insert(workspaceSessions)
+            .values({
+            id: session.id,
+            root: session.root,
+            status: session.status,
+            mode: session.mode,
+            sourceRoot: session.sourceRoot ?? null,
+            baseRef: session.baseRef ?? null,
+            baseSha: session.baseSha ?? null,
+            managed: String(session.managed),
+            createdAt: session.createdAt,
+            lastUsedAt: session.lastUsedAt,
+        })
+            .run();
+        return session;
+    }
+    getSession(id) {
+        const row = this.database.db
+            .select()
+            .from(workspaceSessions)
+            .where(eq(workspaceSessions.id, id))
+            .get();
+        return row ? rowToWorkspaceSession(row) : undefined;
+    }
+    touchSession(id) {
+        this.database.db
+            .update(workspaceSessions)
+            .set({ lastUsedAt: new Date().toISOString() })
+            .where(eq(workspaceSessions.id, id))
+            .run();
+    }
+    updateSession(id, updates) {
+        const toSet = {};
+        if (updates.status !== undefined)
+            toSet.status = updates.status;
+        if (updates.mode !== undefined)
+            toSet.mode = updates.mode;
+        if (updates.root !== undefined)
+            toSet.root = updates.root;
+        if (Object.keys(toSet).length === 0)
+            return;
+        this.database.db
+            .update(workspaceSessions)
+            .set(toSet)
+            .where(eq(workspaceSessions.id, id))
+            .run();
+    }
+    getDatabase() {
+        return this.database;
+    }
+    close() {
+        this.database.close();
+    }
+    migrate() {
+        this.database.sqlite.exec(`
+      create table if not exists _migrations (
+        name text primary key,
+        applied_at text not null
+      )
+    `);
+        const applied = new Set(this.database.sqlite.prepare("select name from _migrations").all().map((r) => r.name));
+        this.database.sqlite.transaction(() => {
+            if (!applied.has("v1_core_tables")) {
+                this.database.sqlite.exec(`
+          create table if not exists workspace_sessions (
+            id text primary key,
+            root text not null,
+            status text not null default 'active',
+            mode text not null default 'checkout',
+            source_root text,
+            base_ref text,
+            base_sha text,
+            managed text not null default 'false',
+            created_at text not null,
+            last_used_at text not null
+          );
+
+          create index if not exists workspace_sessions_root_idx
+            on workspace_sessions(root, last_used_at desc);
+
+          create index if not exists workspace_sessions_status_idx
+            on workspace_sessions(status, last_used_at desc);
+
+          create table if not exists loaded_agent_files (
+            workspace_session_id text not null,
+            path text not null,
+            content_hash text not null,
+            content text not null,
+            loaded_at text not null,
+            last_seen_at text not null,
+            primary key (workspace_session_id, path),
+            foreign key (workspace_session_id)
+              references workspace_sessions(id)
+              on delete cascade
+          );
+
+          create index if not exists loaded_agent_files_path_idx
+            on loaded_agent_files(path);
+
+          create table if not exists rooms (
+            id text primary key,
+            owner_client_id text not null,
+            workspace_id text not null unique,
+            state text not null default 'active',
+            created_at text not null,
+            last_activity_at text not null,
+            closed_at text
+          );
+
+          create index if not exists rooms_workspace_idx
+            on rooms(workspace_id);
+
+          create index if not exists rooms_owner_idx
+            on rooms(owner_client_id);
+        `);
+                this.database.sqlite
+                    .prepare("insert into _migrations (name, applied_at) values (?, ?)")
+                    .run("v1_core_tables", new Date().toISOString());
+            }
+            const alterMigrations = [
+                { name: "v1_add_mode", column: "mode", def: "text not null default 'checkout'" },
+                { name: "v1_add_source_root", column: "source_root", def: "text" },
+                { name: "v1_add_base_ref", column: "base_ref", def: "text" },
+                { name: "v1_add_base_sha", column: "base_sha", def: "text" },
+                { name: "v1_add_managed", column: "managed", def: "text not null default 'false'" },
+            ];
+            for (const m of alterMigrations) {
+                if (!applied.has(m.name)) {
+                    this.backupDb();
+                    this.addColumnIfMissing("workspace_sessions", m.column, m.def);
+                    this.database.sqlite
+                        .prepare("insert into _migrations (name, applied_at) values (?, ?)")
+                        .run(m.name, new Date().toISOString());
+                }
+            }
+        })();
+    }
+    backupDb() {
+        const dbPath = databasePath(this.stateDir);
+        const backupPath = join(this.stateDir, "auvrynt.sqlite.migrate.bak");
+        try {
+            copyFileSync(dbPath, backupPath);
+        }
+        catch {
+            // Backup is best-effort
+        }
+    }
+    addColumnIfMissing(table, column, definition) {
+        const columns = this.database.sqlite.prepare(`pragma table_info(${table})`).all();
+        if (columns.some((existingColumn) => existingColumn.name === column))
+            return;
+        this.database.sqlite.exec(`alter table ${table} add column ${column} ${definition}`);
+    }
+    pruneStaleSessions() {
+        const cutoff = new Date(Date.now() - WORKSPACE_SESSION_TTL_MS).toISOString();
+        const transaction = this.database.sqlite.transaction(() => {
+            this.database.sqlite
+                .prepare("delete from workspace_sessions where last_used_at < ?")
+                .run(cutoff);
+            this.database.sqlite.prepare(`
+        delete from workspace_sessions
+        where id in (
+          select id from workspace_sessions
+          order by last_used_at desc
+          limit -1 offset ?
+        )
+      `).run(MAX_PERSISTED_WORKSPACE_SESSIONS);
+        });
+        transaction();
+    }
+}
+export function createWorkspaceStore(stateDir) {
+    return new SqliteWorkspaceStore(stateDir);
+}
+function rowToWorkspaceSession(row) {
+    return {
+        id: row.id,
+        root: row.root,
+        status: row.status,
+        mode: row.mode === "worktree" ? "worktree" : "checkout",
+        sourceRoot: row.sourceRoot ?? undefined,
+        baseRef: row.baseRef ?? undefined,
+        baseSha: row.baseSha ?? undefined,
+        managed: row.managed === "true",
+        createdAt: row.createdAt,
+        lastUsedAt: row.lastUsedAt,
+    };
+}

package/dist/workspace/workspaces.js

@@ -0,0 +1,314 @@
+import { randomUUID } from "node:crypto";
+import { existsSync } from "node:fs";
+import { mkdir, opendir, stat } from "node:fs/promises";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { loadProjectContextFiles } from "@earendil-works/pi-coding-agent";
+import { createManagedWorktree } from "./git-worktrees.js";
+import { AccessDeniedError, assertAllowedPath, isPathInsideRoot, resolveAllowedPath } from "./roots.js";
+import { loadWorkspaceSkills, markSkillActivated, resolveSkillReadPath, } from "./skills.js";
+const MAX_ACTIVE_WORKSPACES = 128;
+const ARTIFACT_DIRECTORY = "auvrynt-logs";
+export class WorkspaceRegistry {
+    config;
+    store;
+    workspaces = new Map();
+    maxActiveWorkspaces;
+    pendingWorkspaceOpens = 0;
+    constructor(config, store, options = {}) {
+        this.config = config;
+        this.store = store;
+        this.maxActiveWorkspaces = Number.isInteger(options.maxActiveWorkspaces)
+            && options.maxActiveWorkspaces > 0
+            ? options.maxActiveWorkspaces
+            : MAX_ACTIVE_WORKSPACES;
+    }
+    async openWorkspace(input) {
+        if (this.workspaces.size + this.pendingWorkspaceOpens >= this.maxActiveWorkspaces) {
+            throw new Error(`Workspace capacity reached (max ${this.maxActiveWorkspaces} active workspaces). Close an unused workspace before opening another.`);
+        }
+        this.pendingWorkspaceOpens += 1;
+        try {
+            const options = typeof input === "string" ? { path: input } : input;
+            const mode = options.mode ?? "checkout";
+            if (mode === "worktree") {
+                return await this.openWorktreeWorkspace(options.path, options.baseRef);
+            }
+            return await this.openCheckoutWorkspace(options.path);
+        }
+        finally {
+            this.pendingWorkspaceOpens = Math.max(0, this.pendingWorkspaceOpens - 1);
+        }
+    }
+    markClosed(workspaceId) {
+        const workspace = this.workspaces.get(workspaceId);
+        if (workspace)
+            workspace.closed = true;
+        this.workspaces.delete(workspaceId);
+        this.store?.updateSession(workspaceId, { status: "closed" });
+    }
+    getWorkspace(workspaceId) {
+        const workspace = this.workspaces.get(workspaceId);
+        if (workspace) {
+            if (workspace.closed) {
+                throw new Error(`Workspace ${workspaceId} has been closed. Call open_workspace to reopen.`);
+            }
+            this.store?.touchSession(workspaceId);
+            return workspace;
+        }
+        const session = this.store?.getSession(workspaceId);
+        if (!session) {
+            throw new Error(`Unknown workspaceId: ${workspaceId}. Call open_workspace first.`);
+        }
+        if (session.status !== "active") {
+            throw new Error(`Workspace ${workspaceId} has been closed. Call open_workspace to reopen.`);
+        }
+        const root = this.assertWorkspaceRootAllowed(session.root, session.mode, session.sourceRoot);
+        if (this.workspaces.size + this.pendingWorkspaceOpens >= this.maxActiveWorkspaces) {
+            throw new Error(`Workspace capacity reached (max ${this.maxActiveWorkspaces} active workspaces).`);
+        }
+        if (session.mode === "worktree" && !existsSync(root)) {
+            console.warn(`[auvrynt] Worktree directory for session ${session.id} no longer exists at ${root}. Falling back to checkout mode.`);
+            session.mode = "checkout";
+            this.store?.updateSession(session.id, { mode: "checkout" });
+        }
+        const restoredWorkspace = {
+            id: session.id,
+            root,
+            mode: session.mode,
+            sourceRoot: session.sourceRoot,
+            worktree: session.mode === "worktree"
+                ? {
+                    path: root,
+                    baseRef: session.baseRef ?? "HEAD",
+                    baseSha: session.baseSha ?? "",
+                    dirtySource: false,
+                    detached: true,
+                    managed: session.managed,
+                }
+                : undefined,
+            ...this.loadSkillsForWorkspace(root),
+            activatedSkillDirs: new Set(),
+        };
+        this.store?.touchSession(workspaceId);
+        this.workspaces.set(restoredWorkspace.id, restoredWorkspace);
+        return restoredWorkspace;
+    }
+    resolvePath(workspace, inputPath) {
+        const absolutePath = resolveAllowedPath(inputPath, workspace.root, [workspace.root]);
+        if (!isPathInsideRoot(absolutePath, workspace.root)) {
+            throw new Error(`Path is outside workspace root: ${inputPath}`);
+        }
+        return absolutePath;
+    }
+    resolveArtifactPath(workspace, inputPath, category) {
+        const normalized = inputPath.replace(/\\/g, "/").replace(/^\.\/+/, "");
+        if (isAbsolute(inputPath) ||
+            /^[a-zA-Z]:\//.test(normalized) ||
+            normalized.startsWith("//") ||
+            normalized.split("/").some((segment) => segment === "..")) {
+            throw new AccessDeniedError(`Path is outside allowed roots: ${inputPath}`);
+        }
+        const withoutRoot = normalized === ARTIFACT_DIRECTORY
+            ? ""
+            : normalized.startsWith(`${ARTIFACT_DIRECTORY}/`)
+                ? normalized.slice(ARTIFACT_DIRECTORY.length + 1)
+                : normalized;
+        const categoryPath = category && withoutRoot !== category && !withoutRoot.startsWith(`${category}/`)
+            ? `${category}/${withoutRoot}`
+            : withoutRoot;
+        const artifactRoot = join(workspace.root, ARTIFACT_DIRECTORY);
+        return resolveAllowedPath(categoryPath || ".", artifactRoot, [artifactRoot]);
+    }
+    resolveReadPath(workspace, inputPath) {
+        try {
+            return {
+                absolutePath: this.resolvePath(workspace, inputPath),
+                readRoots: [workspace.root],
+            };
+        }
+        catch (workspaceError) {
+            const skillRead = resolveSkillReadPath(workspace.skills, workspace.activatedSkillDirs, inputPath);
+            if (!skillRead)
+                throw workspaceError;
+            return {
+                absolutePath: skillRead.absolutePath,
+                readRoots: [workspace.root, skillRead.skill.baseDir],
+                skillRead,
+            };
+        }
+    }
+    markReadPathLoaded(workspace, readPath) {
+        if (readPath.skillRead?.isSkillFile) {
+            markSkillActivated(workspace.activatedSkillDirs, readPath.skillRead.skill);
+        }
+    }
+    resolveWorkingDirectory(workspace, workingDirectory) {
+        const directory = workingDirectory ? this.resolvePath(workspace, workingDirectory) : workspace.root;
+        return assertAllowedPath(directory, [workspace.root]);
+    }
+    async openCheckoutWorkspace(path) {
+        const root = assertAllowedPath(path, this.config.allowedRoots);
+        await mkdir(root, { recursive: true });
+        const rootStats = await stat(root);
+        if (!rootStats.isDirectory()) {
+            throw new Error(`Workspace root must be a directory: ${path}`);
+        }
+        return this.createWorkspaceContext({ root, mode: "checkout" });
+    }
+    async openWorktreeWorkspace(path, baseRef) {
+        const worktree = await createManagedWorktree({
+            sourcePath: path,
+            baseRef,
+            config: this.config,
+        });
+        return this.createWorkspaceContext({
+            root: worktree.path,
+            mode: "worktree",
+            sourceRoot: worktree.sourceRoot,
+            worktree,
+        });
+    }
+    async createWorkspaceContext(input) {
+        const workspace = {
+            id: `ws_${randomUUID()}`,
+            root: input.root,
+            mode: input.mode,
+            sourceRoot: input.sourceRoot,
+            worktree: input.worktree,
+            ...this.loadSkillsForWorkspace(input.root),
+            activatedSkillDirs: new Set(),
+        };
+        const agentsFiles = this.loadInitialAgentsFiles(workspace.root);
+        const availableAgentsFiles = await this.findAvailableAgentsFiles(workspace.root, agentsFiles);
+        this.store?.createSession({
+            id: workspace.id,
+            root: workspace.root,
+            mode: workspace.mode,
+            sourceRoot: workspace.sourceRoot,
+            baseRef: workspace.worktree?.baseRef,
+            baseSha: workspace.worktree?.baseSha,
+            managed: workspace.worktree?.managed,
+        });
+        this.workspaces.set(workspace.id, workspace);
+        return { workspace, agentsFiles, availableAgentsFiles };
+    }
+    replaceAllowedRoots(roots) {
+        this.config.allowedRoots.splice(0, this.config.allowedRoots.length, ...roots);
+        const closedWorkspaceIds = [];
+        for (const [workspaceId, workspace] of this.workspaces) {
+            try {
+                this.assertWorkspaceRootAllowed(workspace.root, workspace.mode, workspace.sourceRoot);
+            }
+            catch (error) {
+                if (!(error instanceof AccessDeniedError))
+                    throw error;
+                this.markClosed(workspaceId);
+                closedWorkspaceIds.push(workspaceId);
+            }
+        }
+        return closedWorkspaceIds;
+    }
+    loadSkillsForWorkspace(root) {
+        const result = loadWorkspaceSkills(this.config, root);
+        return {
+            skills: result.skills,
+            skillDiagnostics: result.diagnostics,
+        };
+    }
+    assertWorkspaceRootAllowed(root, mode, sourceRoot) {
+        if (mode === "worktree") {
+            if (!sourceRoot) {
+                throw new Error(`Stored worktree workspace is missing sourceRoot: ${root}`);
+            }
+            assertAllowedPath(sourceRoot, this.config.allowedRoots);
+            return assertAllowedPath(root, [this.config.worktreeRoot]);
+        }
+        return assertAllowedPath(root, this.config.allowedRoots);
+    }
+    loadInitialAgentsFiles(root) {
+        const agentDir = resolve(this.config.agentDir);
+        return loadProjectContextFiles({ cwd: root, agentDir })
+            .filter((file) => {
+            const path = resolve(file.path);
+            if (isPathInsideRoot(path, agentDir))
+                return true;
+            return isPathInsideRoot(path, root) && dirname(path) === root;
+        })
+            .map((file) => ({
+            path: resolve(file.path),
+            content: file.content,
+        }));
+    }
+    async findAvailableAgentsFiles(root, loadedFiles) {
+        const loadedPaths = new Set(loadedFiles.map((file) => resolve(file.path)));
+        const discovered = [];
+        await walkWorkspace(root, async (path, entry) => {
+            if (!entry.isFile())
+                return;
+            if (!CONTEXT_FILE_NAMES.has(entry.name))
+                return;
+            if (loadedPaths.has(path))
+                return;
+            if (discovered.length >= MAX_DISCOVERED_CONTEXT_FILES)
+                return;
+            discovered.push({ path });
+        });
+        return discovered.sort((a, b) => a.path.localeCompare(b.path));
+    }
+}
+const CONTEXT_FILE_NAMES = new Set(["AGENTS.md", "AGENTS.MD", "CLAUDE.md", "CLAUDE.MD"]);
+const MAX_CONTEXT_SCAN_ENTRIES = 50_000;
+const MAX_CONTEXT_SCAN_DEPTH = 16;
+const MAX_DISCOVERED_CONTEXT_FILES = 256;
+const SKIPPED_CONTEXT_DIRS = new Set([
+    ".git",
+    ".hg",
+    ".svn",
+    ".auvrynt",
+    "node_modules",
+    "dist",
+    "build",
+    ".next",
+    ".turbo",
+    ".cache",
+]);
+export function formatAgentsPath(path, workspaceRoot) {
+    if (!workspaceRoot)
+        return path.split(sep).join("/");
+    const relationship = relative(workspaceRoot, path);
+    if (relationship === "" ||
+        relationship.startsWith("..") ||
+        relationship === ".." ||
+        relationship.includes(`..${sep}`)) {
+        return path.split(sep).join("/");
+    }
+    return relationship.split(sep).join("/");
+}
+async function walkWorkspace(directory, visit, state = { entries: 0, stopped: false }, depth = 0) {
+    if (state.stopped || depth > MAX_CONTEXT_SCAN_DEPTH)
+        return;
+    let entries;
+    try {
+        entries = await opendir(directory);
+    }
+    catch {
+        return;
+    }
+    for await (const entry of entries) {
+        if (state.stopped)
+            break;
+        state.entries += 1;
+        if (state.entries > MAX_CONTEXT_SCAN_ENTRIES) {
+            state.stopped = true;
+            break;
+        }
+        const path = join(directory, entry.name);
+        if (entry.isDirectory()) {
+            if (!SKIPPED_CONTEXT_DIRS.has(entry.name)) {
+                await walkWorkspace(path, visit, state, depth + 1);
+            }
+            continue;
+        }
+        await visit(path, entry);
+    }
+}

package/dist/workspace-store.js

@@ -1,125 +1 @@
-import { eq } from "drizzle-orm";
-import { openDatabase } from "./db/client.js";
-import { workspaceSessions, } from "./db/schema.js";
-export class SqliteWorkspaceStore {
-    database;
-    constructor(stateDir) {
-        this.database = openDatabase(stateDir);
-        this.migrate();
-    }
-    createSession(input) {
-        const now = new Date().toISOString();
-        const session = {
-            id: input.id,
-            root: input.root,
-            status: "active",
-            mode: input.mode ?? "checkout",
-            sourceRoot: input.sourceRoot,
-            baseRef: input.baseRef,
-            baseSha: input.baseSha,
-            managed: input.managed ?? false,
-            createdAt: now,
-            lastUsedAt: now,
-        };
-        this.database.db
-            .insert(workspaceSessions)
-            .values({
-            id: session.id,
-            root: session.root,
-            status: session.status,
-            mode: session.mode,
-            sourceRoot: session.sourceRoot ?? null,
-            baseRef: session.baseRef ?? null,
-            baseSha: session.baseSha ?? null,
-            managed: String(session.managed),
-            createdAt: session.createdAt,
-            lastUsedAt: session.lastUsedAt,
-        })
-            .run();
-        return session;
-    }
-    getSession(id) {
-        const row = this.database.db
-            .select()
-            .from(workspaceSessions)
-            .where(eq(workspaceSessions.id, id))
-            .get();
-        return row ? rowToWorkspaceSession(row) : undefined;
-    }
-    touchSession(id) {
-        this.database.db
-            .update(workspaceSessions)
-            .set({ lastUsedAt: new Date().toISOString() })
-            .where(eq(workspaceSessions.id, id))
-            .run();
-    }
-    close() {
-        this.database.close();
-    }
-    migrate() {
-        this.database.sqlite.exec(`
-      create table if not exists workspace_sessions (
-        id text primary key,
-        root text not null,
-        status text not null default 'active',
-        mode text not null default 'checkout',
-        source_root text,
-        base_ref text,
-        base_sha text,
-        managed text not null default 'false',
-        created_at text not null,
-        last_used_at text not null
-      );
-
-      create index if not exists workspace_sessions_root_idx
-        on workspace_sessions(root, last_used_at desc);
-
-      create index if not exists workspace_sessions_status_idx
-        on workspace_sessions(status, last_used_at desc);
-
-      create table if not exists loaded_agent_files (
-        workspace_session_id text not null,
-        path text not null,
-        content_hash text not null,
-        content text not null,
-        loaded_at text not null,
-        last_seen_at text not null,
-        primary key (workspace_session_id, path),
-        foreign key (workspace_session_id)
-          references workspace_sessions(id)
-          on delete cascade
-      );
-
-      create index if not exists loaded_agent_files_path_idx
-        on loaded_agent_files(path);
-    `);
-        this.addColumnIfMissing("workspace_sessions", "mode", "text not null default 'checkout'");
-        this.addColumnIfMissing("workspace_sessions", "source_root", "text");
-        this.addColumnIfMissing("workspace_sessions", "base_ref", "text");
-        this.addColumnIfMissing("workspace_sessions", "base_sha", "text");
-        this.addColumnIfMissing("workspace_sessions", "managed", "text not null default 'false'");
-    }
-    addColumnIfMissing(table, column, definition) {
-        const columns = this.database.sqlite.prepare(`pragma table_info(${table})`).all();
-        if (columns.some((existingColumn) => existingColumn.name === column))
-            return;
-        this.database.sqlite.exec(`alter table ${table} add column ${column} ${definition}`);
-    }
-}
-export function createWorkspaceStore(stateDir) {
-    return new SqliteWorkspaceStore(stateDir);
-}
-function rowToWorkspaceSession(row) {
-    return {
-        id: row.id,
-        root: row.root,
-        status: row.status,
-        mode: row.mode === "worktree" ? "worktree" : "checkout",
-        sourceRoot: row.sourceRoot ?? undefined,
-        baseRef: row.baseRef ?? undefined,
-        baseSha: row.baseSha ?? undefined,
-        managed: row.managed === "true",
-        createdAt: row.createdAt,
-        lastUsedAt: row.lastUsedAt,
-    };
-}
+export * from "./workspace/workspace-store.js";