skimpyclaw 0.3.6 → 0.3.9

package/dist/code-agents/worktree.js

@@ -0,0 +1,215 @@
+// Git worktree isolation for parallel coding agents.
+// Each parallel child gets its own worktree so they can't overwrite each other.
+import { execSync } from 'child_process';
+import { existsSync, rmSync } from 'fs';
+import { join } from 'path';
+/**
+ * Check if a directory is inside a git repo.
+ */
+export function isGitRepo(workdir) {
+    try {
+        execSync('git rev-parse --is-inside-work-tree', {
+            cwd: workdir,
+            timeout: 5000,
+            encoding: 'utf-8',
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Get the git repo root directory.
+ */
+export function getGitRoot(workdir) {
+    return execSync('git rev-parse --show-toplevel', {
+        cwd: workdir,
+        timeout: 5000,
+        encoding: 'utf-8',
+        stdio: ['ignore', 'pipe', 'pipe'],
+    }).trim();
+}
+/**
+ * Stage and commit all current changes so worktrees branch from a clean state.
+ * Returns the commit hash, or null if nothing to commit.
+ */
+export function commitPendingChanges(workdir, message) {
+    try {
+        // Check for any changes (staged or unstaged)
+        const status = execSync('git status --porcelain', {
+            cwd: workdir,
+            timeout: 5000,
+            encoding: 'utf-8',
+            stdio: ['ignore', 'pipe', 'pipe'],
+        }).trim();
+        if (!status)
+            return null;
+        execSync('git add -A && git commit -m ' + JSON.stringify(message), {
+            cwd: workdir,
+            timeout: 10000,
+            encoding: 'utf-8',
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        return execSync('git rev-parse HEAD', {
+            cwd: workdir,
+            timeout: 5000,
+            encoding: 'utf-8',
+            stdio: ['ignore', 'pipe', 'pipe'],
+        }).trim();
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Create a git worktree for a child agent.
+ * Creates a new branch and worktree directory under .skimpyclaw-worktrees/.
+ */
+export function createWorktree(workdir, childId) {
+    const gitRoot = getGitRoot(workdir);
+    const worktreeDir = join(gitRoot, '.skimpyclaw-worktrees', childId);
+    const branch = `skimpyclaw-team/${childId}`;
+    // Clean up stale worktree/branch if they exist
+    try {
+        execSync(`git worktree remove --force ${JSON.stringify(worktreeDir)}`, {
+            cwd: gitRoot,
+            timeout: 10000,
+            encoding: 'utf-8',
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+    }
+    catch { /* didn't exist */ }
+    try {
+        execSync(`git branch -D ${JSON.stringify(branch)}`, {
+            cwd: gitRoot,
+            timeout: 5000,
+            encoding: 'utf-8',
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+    }
+    catch { /* didn't exist */ }
+    // Create worktree on a new branch from HEAD
+    execSync(`git worktree add -b ${JSON.stringify(branch)} ${JSON.stringify(worktreeDir)} HEAD`, {
+        cwd: gitRoot,
+        timeout: 15000,
+        encoding: 'utf-8',
+        stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    return { path: worktreeDir, branch };
+}
+/**
+ * Merge a child's worktree branch back into the current branch.
+ * Returns { merged: true } on success, { merged: false, conflict: string } on conflict.
+ */
+export function mergeWorktree(workdir, branch, childId) {
+    const gitRoot = getGitRoot(workdir);
+    try {
+        // First check if the child branch has any changes compared to where it branched
+        const diff = execSync(`git diff HEAD...${JSON.stringify(branch)} --stat`, {
+            cwd: gitRoot,
+            timeout: 10000,
+            encoding: 'utf-8',
+            stdio: ['ignore', 'pipe', 'pipe'],
+        }).trim();
+        if (!diff) {
+            // No changes on child branch — nothing to merge
+            return { merged: true };
+        }
+        execSync(`git merge --no-edit ${JSON.stringify(branch)}`, {
+            cwd: gitRoot,
+            timeout: 15000,
+            encoding: 'utf-8',
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        return { merged: true };
+    }
+    catch (err) {
+        // Merge conflict — abort and report
+        try {
+            execSync('git merge --abort', {
+                cwd: gitRoot,
+                timeout: 5000,
+                encoding: 'utf-8',
+                stdio: ['ignore', 'pipe', 'pipe'],
+            });
+        }
+        catch { /* no merge in progress */ }
+        const conflict = err instanceof Error ? err.message : String(err);
+        return { merged: false, conflict: conflict.slice(0, 2000) };
+    }
+}
+/**
+ * Remove a worktree and its branch.
+ */
+export function removeWorktree(workdir, childId, branch) {
+    const gitRoot = getGitRoot(workdir);
+    const worktreeDir = join(gitRoot, '.skimpyclaw-worktrees', childId);
+    try {
+        execSync(`git worktree remove --force ${JSON.stringify(worktreeDir)}`, {
+            cwd: gitRoot,
+            timeout: 10000,
+            encoding: 'utf-8',
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+    }
+    catch { /* already removed */ }
+    // Clean up directory if git worktree remove didn't
+    if (existsSync(worktreeDir)) {
+        rmSync(worktreeDir, { recursive: true, force: true });
+    }
+    try {
+        execSync(`git branch -D ${JSON.stringify(branch)}`, {
+            cwd: gitRoot,
+            timeout: 5000,
+            encoding: 'utf-8',
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+    }
+    catch { /* already deleted */ }
+}
+/**
+ * Clean up all skimpyclaw worktrees in a repo (e.g. on crash recovery).
+ */
+export function cleanupAllWorktrees(workdir) {
+    const gitRoot = getGitRoot(workdir);
+    const worktreeBaseDir = join(gitRoot, '.skimpyclaw-worktrees');
+    // Prune stale worktree references
+    try {
+        execSync('git worktree prune', {
+            cwd: gitRoot,
+            timeout: 10000,
+            encoding: 'utf-8',
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+    }
+    catch { /* ignore */ }
+    // Remove the directory
+    if (existsSync(worktreeBaseDir)) {
+        rmSync(worktreeBaseDir, { recursive: true, force: true });
+    }
+    // Delete all skimpyclaw-team/* branches
+    try {
+        const branches = execSync('git branch --list "skimpyclaw-team/*"', {
+            cwd: gitRoot,
+            timeout: 5000,
+            encoding: 'utf-8',
+            stdio: ['ignore', 'pipe', 'pipe'],
+        }).trim();
+        if (branches) {
+            for (const b of branches.split('\n').map(s => s.trim()).filter(Boolean)) {
+                try {
+                    execSync(`git branch -D ${JSON.stringify(b)}`, {
+                        cwd: gitRoot,
+                        timeout: 5000,
+                        encoding: 'utf-8',
+                        stdio: ['ignore', 'pipe', 'pipe'],
+                    });
+                }
+                catch { /* ignore */ }
+            }
+        }
+    }
+    catch { /* ignore */ }
+}

package/dist/config.d.ts

@@ -2,6 +2,7 @@ import type { Config } from './types.js';
 export declare function loadConfig(): Config;
 export declare function loadRawConfig(): Record<string, any>;
 export declare function getConfigPath(): string;
+export declare function isValidAgentId(agentId: string): boolean;
 export declare function getAgentDir(agentId: string): string;
 export declare function getLogsDir(): string;
 export declare function getSessionsDir(): string;

package/dist/config.js

@@ -54,8 +54,11 @@ export function loadRawConfig() {
 export function getConfigPath() {
     return CONFIG_PATH;
 }
+export function isValidAgentId(agentId) {
+    return /^[a-zA-Z0-9_-]+$/.test(agentId);
+}
 export function getAgentDir(agentId) {
-    if (!/^[a-zA-Z0-9_-]+$/.test(agentId)) {
+    if (!isValidAgentId(agentId)) {
         throw new Error('Invalid agent ID');
     }
     return join(homedir(), '.skimpyclaw', 'agents', agentId);
@@ -107,8 +110,7 @@ export function listMemoryFiles(agentId) {
     }).sort((a, b) => b.date.localeCompare(a.date));
 }
 export function readMemoryFile(agentId, filename) {
-    // Validate agentId is a safe identifier
-    if (!/^[a-zA-Z0-9_-]+$/.test(agentId)) {
+    if (!isValidAgentId(agentId)) {
         throw new Error('Invalid agent ID');
     }
     // Validate no path traversal

package/dist/cron.js

@@ -10,6 +10,20 @@ import { startTrace, addEvent, endTrace } from './audit.js';
 import { sendActiveChannelProactiveMessage, sendActiveChannelProactiveVoice, getActiveChannelId } from './channels.js';
 import { parseAndSaveDigest } from './digests.js';
 import { synthesizeSpeech } from './voice.js';
+import { toErrorMessage } from './utils.js';
+function safeTimezone(tz) {
+    const fallback = Intl.DateTimeFormat().resolvedOptions().timeZone || 'UTC';
+    if (!tz)
+        return fallback;
+    try {
+        Intl.DateTimeFormat(undefined, { timeZone: tz });
+        return tz;
+    }
+    catch {
+        console.warn(`[cron] Invalid timezone "${tz}", falling back to ${fallback}`);
+        return fallback;
+    }
+}
 import { ensureContainer, SANDBOX_DEFAULTS, sandboxBash } from './sandbox/index.js';
 const scheduledJobs = new Map();
 let configWatcher = null;
@@ -100,7 +114,7 @@ function scheduleJob(jobDef, config) {
         return;
     }
     const cronJob = new Cron(jobDef.schedule.expr, {
-        timezone: jobDef.schedule.tz || 'America/Chicago',
+        timezone: safeTimezone(jobDef.schedule.tz),
     }, async () => {
         console.log(`[cron] Running job: ${jobDef.name}`);
         await executeJobPayload(jobDef, config);
@@ -235,7 +249,7 @@ async function executeJobPayload(jobDef, config) {
         appendCronLogLine(jobDef.id, `=== COMPLETED: success ===`);
     }
     catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
+        const msg = toErrorMessage(err);
         logEntry.status = msg.includes('TIMEOUT') || msg.includes('timed out') ? 'timeout' : 'error';
         logEntry.error = msg;
         appendCronLogLine(jobDef.id, `=== FAILED: ${logEntry.status} — ${msg.slice(0, 200)} ===`);
@@ -337,14 +351,14 @@ function resolveMessageSource(message) {
         return message;
     // Expand ~ to home directory
     const resolved = trimmed.startsWith('~/')
-        ? join(process.env.HOME || '', trimmed.slice(2))
+        ? join(homedir(), trimmed.slice(2))
         : trimmed;
     if (existsSync(resolved)) {
         console.log(`[cron] Loading prompt from file: ${resolved}`);
         return readFileSync(resolved, 'utf-8');
     }
     // Fallback: check ~/.skimpyclaw/prompts/ directory
-    const promptsDir = join(process.env.HOME || '', '.skimpyclaw', 'prompts', trimmed);
+    const promptsDir = join(homedir(), '.skimpyclaw', 'prompts', trimmed);
     if (existsSync(promptsDir)) {
         console.log(`[cron] Loading prompt from prompts dir: ${promptsDir}`);
         return readFileSync(promptsDir, 'utf-8');