profclaw 2.0.0 → 2.3.0

package/dist/agents/worktree-manager.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Worktree Manager
+ *
+ * Provides git worktree isolation for agent tasks. Each task can optionally
+ * run in its own git worktree so concurrent agents don't create dirty-tree
+ * conflicts on the main working tree.
+ *
+ * All git operations use execFile (not shell) to avoid injection risks.
+ */
+export interface WorktreeInfo {
+    /** Absolute path to the worktree directory */
+    path: string;
+    /** Branch checked out in this worktree */
+    branch: string;
+    /** Branch the worktree was created from */
+    baseBranch: string;
+    /** Unix timestamp (ms) when this worktree was created */
+    createdAt: number;
+    /** Optional task identifier that owns this worktree */
+    taskId?: string;
+}
+export interface MergeResult {
+    success: boolean;
+    /** Conflicting file paths when success is false */
+    conflicts?: string[];
+}
+export declare class WorktreeManager {
+    private readonly worktrees;
+    /** Absolute path to the directory that holds all created worktrees */
+    private readonly baseDir;
+    /** Resolved project root (the main git working tree) */
+    private readonly projectRoot;
+    constructor(projectRoot?: string);
+    /**
+     * Create an isolated worktree for a task.
+     *
+     * Runs: git worktree add <path> -b <branch> [baseBranch]
+     */
+    create(options: {
+        taskId: string;
+        /** Branch to base the new worktree on (defaults to current HEAD branch) */
+        baseBranch?: string;
+        /** Name for the new branch (defaults to profclaw/task-{taskId}) */
+        branchName?: string;
+    }): Promise<WorktreeInfo>;
+    /** Return all active worktrees tracked by this manager instance. */
+    list(): WorktreeInfo[];
+    /** Return the WorktreeInfo for a specific task, or undefined if unknown. */
+    get(taskId: string): WorktreeInfo | undefined;
+    /**
+     * Merge the worktree's branch back into its base branch.
+     *
+     * Runs: git merge [--squash] <branch>  (executed from the base worktree)
+     */
+    merge(taskId: string, options?: {
+        squash?: boolean;
+        message?: string;
+    }): Promise<MergeResult>;
+    /**
+     * Remove a worktree from disk and deregister it.
+     *
+     * Runs: git worktree remove <path>
+     */
+    remove(taskId: string): Promise<void>;
+    /**
+     * Prune stale worktree metadata that git is tracking but whose paths no
+     * longer exist on disk.
+     *
+     * Runs: git worktree prune
+     *
+     * @returns Number of pruned entries as reported by git
+     */
+    prune(): Promise<number>;
+}
+/**
+ * Return a shared WorktreeManager rooted at the current working directory.
+ * Use the WorktreeManager constructor directly if you need a different root.
+ */
+export declare function getWorktreeManager(): WorktreeManager;
+//# sourceMappingURL=worktree-manager.d.ts.map

package/dist/agents/worktree-manager.js

@@ -0,0 +1,203 @@
+/**
+ * Worktree Manager
+ *
+ * Provides git worktree isolation for agent tasks. Each task can optionally
+ * run in its own git worktree so concurrent agents don't create dirty-tree
+ * conflicts on the main working tree.
+ *
+ * All git operations use execFile (not shell) to avoid injection risks.
+ */
+import { execFile as execFileCb } from "node:child_process";
+import { promisify } from "node:util";
+import { mkdir, rm } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { logger } from '../utils/logger.js';
+const execFile = promisify(execFileCb);
+// Helpers
+function sanitizeBranchName(name) {
+    // Strip characters that are not safe in git branch names
+    return name.replace(/[^a-zA-Z0-9/_.-]/g, "-").replace(/^[-.]|[-.]$/g, "");
+}
+async function getCurrentBranch(cwd) {
+    const { stdout } = await execFile("git", ["rev-parse", "--abbrev-ref", "HEAD"], { cwd });
+    return stdout.trim();
+}
+async function isGitRepo(dir) {
+    try {
+        await execFile("git", ["rev-parse", "--git-dir"], { cwd: dir });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// WorktreeManager
+export class WorktreeManager {
+    worktrees = new Map();
+    /** Absolute path to the directory that holds all created worktrees */
+    baseDir;
+    /** Resolved project root (the main git working tree) */
+    projectRoot;
+    constructor(projectRoot) {
+        this.projectRoot = resolve(projectRoot ?? process.cwd());
+        this.baseDir = join(this.projectRoot, ".profclaw", "worktrees");
+    }
+    /**
+     * Create an isolated worktree for a task.
+     *
+     * Runs: git worktree add <path> -b <branch> [baseBranch]
+     */
+    async create(options) {
+        const { taskId } = options;
+        if (!(await isGitRepo(this.projectRoot))) {
+            throw new Error(`[WorktreeManager] ${this.projectRoot} is not a git repository`);
+        }
+        const baseBranch = options.baseBranch ?? (await getCurrentBranch(this.projectRoot));
+        const rawBranch = options.branchName ?? `profclaw/task-${taskId}`;
+        const branch = sanitizeBranchName(rawBranch);
+        const worktreePath = join(this.baseDir, taskId);
+        // Ensure the base directory exists
+        await mkdir(this.baseDir, { recursive: true });
+        try {
+            await execFile("git", ["worktree", "add", worktreePath, "-b", branch, baseBranch], { cwd: this.projectRoot });
+        }
+        catch (error) {
+            throw new Error(`[WorktreeManager] Failed to create worktree for task ${taskId}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        const info = {
+            path: worktreePath,
+            branch,
+            baseBranch,
+            createdAt: Date.now(),
+            taskId,
+        };
+        this.worktrees.set(taskId, info);
+        logger.info(`[WorktreeManager] Created worktree for task ${taskId} at ${worktreePath}`);
+        return info;
+    }
+    /** Return all active worktrees tracked by this manager instance. */
+    list() {
+        return Array.from(this.worktrees.values());
+    }
+    /** Return the WorktreeInfo for a specific task, or undefined if unknown. */
+    get(taskId) {
+        return this.worktrees.get(taskId);
+    }
+    /**
+     * Merge the worktree's branch back into its base branch.
+     *
+     * Runs: git merge [--squash] <branch>  (executed from the base worktree)
+     */
+    async merge(taskId, options) {
+        const info = this.worktrees.get(taskId);
+        if (!info) {
+            throw new Error(`[WorktreeManager] No worktree found for task ${taskId}`);
+        }
+        try {
+            // Ensure we're on the correct base branch before merging
+            await execFile("git", ["checkout", info.baseBranch], {
+                cwd: this.projectRoot,
+            });
+            if (options?.squash) {
+                // Squash merge requires separate commit step
+                await execFile("git", ["merge", "--squash", info.branch], {
+                    cwd: this.projectRoot,
+                });
+                const commitMsg = options.message || `Squash merge branch '${info.branch}'`;
+                await execFile("git", ["commit", "-m", commitMsg], {
+                    cwd: this.projectRoot,
+                });
+            }
+            else {
+                const mergeArgs = ["merge", info.branch];
+                if (options?.message) {
+                    mergeArgs.push("-m", options.message);
+                }
+                await execFile("git", mergeArgs, { cwd: this.projectRoot });
+            }
+            logger.info(`[WorktreeManager] Merged branch ${info.branch} into ${info.baseBranch}`);
+            return { success: true };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            // Extract conflicting file names from git's error/stdout output
+            const conflicts = message
+                .split("\n")
+                .filter((line) => line.startsWith("CONFLICT"))
+                .map((line) => line.replace(/^CONFLICT[^:]*:\s*/i, "").trim())
+                .filter(Boolean);
+            logger.error(`[WorktreeManager] Merge conflicts for task ${taskId}:`, error instanceof Error ? error : new Error(String(error)));
+            return { success: false, conflicts };
+        }
+    }
+    /**
+     * Remove a worktree from disk and deregister it.
+     *
+     * Runs: git worktree remove <path>
+     */
+    async remove(taskId) {
+        const info = this.worktrees.get(taskId);
+        if (!info) {
+            throw new Error(`[WorktreeManager] No worktree found for task ${taskId}`);
+        }
+        try {
+            await execFile("git", ["worktree", "remove", info.path, "--force"], {
+                cwd: this.projectRoot,
+            });
+        }
+        catch (error) {
+            // If git worktree remove fails (e.g. path already gone) try to clean up
+            // the directory ourselves so we stay consistent.
+            logger.error(`[WorktreeManager] git worktree remove failed for task ${taskId}, attempting manual rm:`, error instanceof Error ? error : new Error(String(error)));
+            try {
+                await rm(info.path, { recursive: true, force: true });
+            }
+            catch (rmError) {
+                logger.error(`[WorktreeManager] Manual rm also failed for ${info.path}:`, rmError instanceof Error ? rmError : new Error(String(rmError)));
+            }
+        }
+        this.worktrees.delete(taskId);
+        logger.info(`[WorktreeManager] Removed worktree for task ${taskId}`);
+    }
+    /**
+     * Prune stale worktree metadata that git is tracking but whose paths no
+     * longer exist on disk.
+     *
+     * Runs: git worktree prune
+     *
+     * @returns Number of pruned entries as reported by git
+     */
+    async prune() {
+        if (!(await isGitRepo(this.projectRoot))) {
+            return 0;
+        }
+        try {
+            const { stderr } = await execFile("git", ["worktree", "prune", "--verbose"], { cwd: this.projectRoot });
+            // git prints one line per pruned entry to stderr when --verbose is given
+            const pruned = stderr
+                .split("\n")
+                .filter((line) => line.trim().length > 0).length;
+            if (pruned > 0) {
+                logger.info(`[WorktreeManager] Pruned ${pruned} stale worktree(s)`);
+            }
+            return pruned;
+        }
+        catch (error) {
+            logger.error(`[WorktreeManager] Failed to prune worktrees:`, error instanceof Error ? error : new Error(String(error)));
+            return 0;
+        }
+    }
+}
+// Singleton
+let _manager;
+/**
+ * Return a shared WorktreeManager rooted at the current working directory.
+ * Use the WorktreeManager constructor directly if you need a different root.
+ */
+export function getWorktreeManager() {
+    if (!_manager) {
+        _manager = new WorktreeManager();
+    }
+    return _manager;
+}
+//# sourceMappingURL=worktree-manager.js.map

package/dist/auth/middleware.js

@@ -14,6 +14,7 @@ import { getSettingsRaw } from '../settings/index.js';
 import { getDb } from '../storage/index.js';
 import { users } from '../storage/schema.js';
 import { eq } from 'drizzle-orm';
+import { getMode } from '../core/deployment.js';
 // Cached admin user for local-mode bypass (avoids DB query per request)
 let cachedLocalAdmin = null;
 let cachedLocalAdminExpiry = 0;
@@ -81,6 +82,19 @@ export function authMiddleware() {
         if (!path.startsWith('/api/') && !path.startsWith('/api')) {
             return next();
         }
+        // Pico mode: no UI dashboard, single-user local device — bypass auth entirely
+        if (getMode() === 'pico') {
+            c.set('user', {
+                id: 'local',
+                name: 'Local User',
+                email: 'local@profclaw',
+                role: 'admin',
+                status: 'active',
+                createdAt: new Date(0),
+                onboardingCompleted: true,
+            });
+            return next();
+        }
         // Local-mode bypass: auto-inject admin user when authMode is 'local'
         // Skip auto-inject if an access key is set (require session cookie instead)
         try {

package/dist/chat/agentic-executor.d.ts

@@ -12,6 +12,7 @@
  * - Provider cooldown tracking
  */
 import { type AgentState } from '../agents/index.js';
+import { type Suggestion } from './proactive/index.js';
 import type { ChatMessage } from '../providers/core/types.js';
 import type { ChatToolHandler } from './tool-handler.js';
 import { type FallbackAttempt } from './failover/index.js';
@@ -24,6 +25,10 @@ export interface AgenticChatRequest {
     temperature?: number;
     /** Thinking effort level for Anthropic models: low (cheap), medium, high, max (deep reasoning) */
     effort?: 'low' | 'medium' | 'high' | 'max';
+    /** User ID for budget tracking and preference recall */
+    userId?: string;
+    /** Team ID for shared budget enforcement */
+    teamId?: string;
     toolHandler: ChatToolHandler;
     tools: Array<{
         name: string;
@@ -68,6 +73,8 @@ export interface AgenticChatResponse {
         requestedModel: string;
         attempts: FallbackAttempt[];
     };
+    /** Proactive follow-up suggestions based on completed task */
+    suggestions?: Suggestion[];
 }
 /**
  * Execute an agentic chat conversation.