wave-agent-sdk 0.19.9 → 1.0.1

package/dist/types/hooks.d.ts

@@ -54,8 +54,8 @@ export declare class HookConfigurationError extends Error {
     readonly validationErrors: string[];
     constructor(configPath: string, validationErrors: string[]);
 }
-export type SessionStartSource = "startup" | "compact" | "clear";
-export type SessionEndSource = "exit" | "stop" | "compact" | "clear";
+export type SessionStartSource = "startup" | "resume" | "compact" | "clear";
+export type SessionEndSource = "exit" | "resume" | "stop" | "compact" | "clear";
 export declare function isValidHookEvent(event: string): event is HookEvent;
 export declare function isValidHookCommand(cmd: unknown): cmd is HookCommand;
 export declare function isValidHookEventConfig(config: unknown): config is HookEventConfig;

package/dist/utils/containerSetup.js

@@ -16,7 +16,6 @@ import { SlashCommandManager } from "../managers/slashCommandManager.js";
 import { PluginManager } from "../managers/pluginManager.js";
 import { BangManager } from "../managers/bangManager.js";
 import { CronManager } from "../managers/cronManager.js";
-import { GoalManager } from "../managers/goalManager.js";
 import { WorkflowManager } from "../managers/workflowManager.js";
 import { MemoryRuleManager } from "../managers/MemoryRuleManager.js";
 import { ReversionManager } from "../managers/reversionManager.js";
@@ -24,6 +23,7 @@ import { SubagentManager } from "../managers/subagentManager.js";
 import { ForkedAgentManager } from "../managers/forkedAgentManager.js";
 import { LiveConfigManager } from "../managers/liveConfigManager.js";
 import { ReversionService } from "../services/reversionService.js";
+import { cleanupMetaOnlySessions } from "../services/session.js";
 import { MemoryService } from "../services/memory.js";
 import { AutoMemoryService } from "../services/autoMemoryService.js";
 import { USER_MEMORY_FILE } from "./constants.js";
@@ -144,6 +144,17 @@ export function setupAgentContainer(setupOptions) {
     reversionService.cleanupOldSessions(30).catch((error) => {
         logger.error("Failed to cleanup old file history:", error);
     });
+    // Remove pre-existing meta-only session files (SessionStart hook context
+    // with no real messages) that were persisted before lazy materialization.
+    cleanupMetaOnlySessions()
+        .then((count) => {
+        if (count > 0) {
+            logger.debug(`Removed ${count} meta-only session file(s)`);
+        }
+    })
+        .catch((error) => {
+        logger.error("Failed to cleanup meta-only session files:", error);
+    });
     const reversionManager = new ReversionManager(container);
     container.register("ReversionManager", reversionManager);
     const canUseToolWithPermissionRequest = options.canUseTool
@@ -159,7 +170,7 @@ export function setupAgentContainer(setupOptions) {
                     toolName: context.toolName,
                     toolInput: context.toolInput,
                     planFilePath: permissionManager.getPlanFilePath(),
-                    env: Object.fromEntries(Object.entries(process.env).filter((e) => e[1] !== undefined)),
+                    env: Object.fromEntries(Object.entries(configurationService.getMergedEnv()).filter((e) => e[1] !== undefined)),
                 });
                 if (results.length > 0) {
                     const processResult = hookManager.processHookResults("PermissionRequest", results, messageManager);
@@ -255,8 +266,6 @@ export function setupAgentContainer(setupOptions) {
     const cronManager = new CronManager(container, messageManager.getSessionId());
     container.register("CronManager", cronManager);
     cronManager.start();
-    const goalManager = new GoalManager(container);
-    container.register("GoalManager", goalManager);
     const workflowManager = new WorkflowManager(container);
     container.register("WorkflowManager", workflowManager);
     return container;

package/dist/utils/openaiClient.js

@@ -36,11 +36,12 @@ export class OpenAIClient {
         };
     }
     async _create(params, options) {
-        const { baseURL, apiKey, defaultHeaders, fetchOptions, fetch: customFetch, } = this.config;
+        const { baseURL, apiKey, sessionId, defaultHeaders, fetchOptions, fetch: customFetch, } = this.config;
         const url = `${baseURL}/chat/completions`;
         const headers = {
             "Content-Type": "application/json",
             ...(apiKey ? { Authorization: `Bearer ${apiKey}` } : {}),
+            ...(sessionId ? { "x-session-id": sessionId } : {}),
             ...defaultHeaders,
         };
         const fetchFn = customFetch || fetch;

package/dist/utils/pathEncoder.js

@@ -127,8 +127,13 @@ export class PathEncoder {
             // If realpath fails, use the absolute path
             resolvedPath = absolutePath;
         }
-        // Encode the resolved path
-        const encodedName = await this.encode(resolvedPath);
+        // Encode the resolved path. Use encodeSync (pure string transform) rather
+        // than encode(): realpath was already attempted above with its own fallback,
+        // so re-resolving via encode()->resolvePath() would throw ENOENT again when
+        // the workdir no longer exists (e.g. a deleted worktree during agent
+        // shutdown). Session files live under <baseSessionDir>/<encoded>/ regardless
+        // of the workdir's existence, so encoding must not require it to exist.
+        const encodedName = this.encodeSync(resolvedPath);
         const encodedPath = join(baseSessionDir, encodedName);
         // Generate hash if encoding resulted in truncation
         let pathHash;

package/dist/utils/worktreeUtils.d.ts

@@ -33,10 +33,27 @@ export declare function getHeadCommit(cwd: string): string;
 export declare function createWorktree(name: string, cwd: string, options?: {
     baseRef?: "fresh" | "head";
 }): WorktreeInfo;
+/**
+ * Set up a freshly created worktree: copy local settings and gitignored
+ * project files (via .worktreeinclude) from the main repo. Best-effort — any
+ * failure only logs a warning and never fails worktree creation.
+ */
+export declare function performPostCreationSetup(worktreePath: string, repoRoot: string): Promise<void>;
 /**
  * Remove a git worktree and its branch.
  */
 export declare function removeWorktree(info: WorktreeInfo): void;
+/**
+ * Validate that a worktree path is safe to remove before running git removal.
+ * Aligns with Claude Code v2.1.216+ background-session checks:
+ * - rejects a path whose final component is a symlink;
+ * - rejects a path that resolves outside the repo root.
+ *
+ * A path that no longer exists (worktree already removed) is allowed so that
+ * removal stays best-effort/idempotent; its nearest existing ancestor is used
+ * for the containment check. Throws an Error on invalid paths.
+ */
+export declare function validateWorktreeRemovalPath(worktreePath: string, repoRoot: string): void;
 /**
  * Count uncommitted files and new commits in a worktree.
  * Returns null if git commands fail (fail-closed).

package/dist/utils/worktreeUtils.js

@@ -2,11 +2,16 @@
  * Git worktree creation and removal utilities for the SDK.
  * Used by EnterWorktree and ExitWorktree tools.
  */
-import { execFileSync } from "node:child_process";
+import { execFile, execFileSync } from "node:child_process";
+import { promisify } from "node:util";
 import * as path from "node:path";
 import * as fs from "node:fs";
 import { getGitMainRepoRoot, getDefaultRemoteBranch, ensureWaveRuntimeFilesExcluded, } from "./gitUtils.js";
 import { logger } from "./globalLogger.js";
+// Post-creation setup runs inside the shared `wave --stdio` process too
+// (desktop sessions), so use the async execFile: a synchronous git call
+// (e.g. `git ls-files` over a large working tree) would freeze every session.
+const execFileAsync = promisify(execFile);
 /**
  * Validate a worktree name to prevent path traversal and invalid characters.
  */
@@ -211,6 +216,288 @@ export function createWorktree(name, cwd, options) {
         throw new Error(`Failed to create worktree: ${error.message}\n${stderr}`);
     }
 }
+/** Translate a single gitignore glob into a RegExp (gitignore semantics). */
+function globToRegExp(glob) {
+    let source = "^";
+    for (let i = 0; i < glob.length; i++) {
+        const ch = glob[i];
+        if (ch === "*") {
+            if (glob[i + 1] === "*") {
+                if (glob[i + 2] === "/") {
+                    // "**/" matches zero or more leading directories
+                    source += "(?:.*/)?";
+                    i += 2;
+                }
+                else {
+                    source += ".*";
+                    i += 1;
+                }
+            }
+            else {
+                source += "[^/]*";
+            }
+        }
+        else if (ch === "?") {
+            source += "[^/]";
+        }
+        else if (ch === "[") {
+            const end = glob.indexOf("]", i + 1);
+            if (end === -1) {
+                source += "\\[";
+            }
+            else {
+                let charClass = glob.slice(i, end + 1);
+                if (charClass.startsWith("[!")) {
+                    // gitignore uses "[!...]" for a negated character class
+                    charClass = "[^" + charClass.slice(2);
+                }
+                source += charClass;
+                i = end;
+            }
+        }
+        else {
+            source += ch.replace(/[.+^${}()|\\]/g, "\\$&");
+        }
+    }
+    source += "$";
+    return new RegExp(source);
+}
+/**
+ * Parse .worktreeinclude content into patterns. Blank lines and "#" comments
+ * are skipped, matching gitignore conventions.
+ */
+function parseWorktreeIncludePatterns(content) {
+    const patterns = [];
+    for (const rawLine of content.split(/\r?\n/)) {
+        const line = rawLine.trim();
+        if (!line || line.startsWith("#"))
+            continue;
+        let raw = line;
+        const negated = raw.startsWith("!");
+        if (negated)
+            raw = raw.slice(1);
+        const dirOnly = raw.endsWith("/");
+        if (dirOnly)
+            raw = raw.slice(0, -1);
+        const anchored = raw.startsWith("/");
+        if (anchored)
+            raw = raw.slice(1);
+        if (!raw)
+            continue;
+        patterns.push({
+            raw,
+            negated,
+            dirOnly,
+            anchored,
+            anyLevel: !anchored && !raw.includes("/"),
+            regex: globToRegExp(raw),
+        });
+    }
+    return patterns;
+}
+/** Test a single pattern against one candidate path. */
+function testPatternAgainst(pattern, candidate) {
+    if (pattern.anyLevel) {
+        // Match the full path or any "/"-suffix (basename at any level)
+        if (pattern.regex.test(candidate))
+            return true;
+        for (let i = 0; i < candidate.length; i++) {
+            if (candidate[i] === "/" && pattern.regex.test(candidate.slice(i + 1))) {
+                return true;
+            }
+        }
+        return false;
+    }
+    return pattern.regex.test(candidate);
+}
+/**
+ * Test a pattern against a path and every ancestor prefix. Excluding a
+ * directory excludes everything beneath it (gitignore semantics), so ancestor
+ * prefixes are always treated as directories.
+ */
+function patternMatchesPath(pattern, relPath, isDir) {
+    let candidate = relPath;
+    for (;;) {
+        const candidateIsDir = candidate === relPath ? isDir : true;
+        if (!(pattern.dirOnly && !candidateIsDir) &&
+            testPatternAgainst(pattern, candidate)) {
+            return true;
+        }
+        const idx = candidate.lastIndexOf("/");
+        if (idx === -1)
+            break;
+        candidate = candidate.slice(0, idx);
+    }
+    return false;
+}
+/** Last-match-wins resolution with "!" negation. */
+function worktreeIncludeMatches(patterns, relPath, isDir) {
+    let matched = false;
+    for (const pattern of patterns) {
+        if (patternMatchesPath(pattern, relPath, isDir)) {
+            matched = !pattern.negated;
+        }
+    }
+    return matched;
+}
+/**
+ * A positive pattern targets something inside a collapsed directory: either it
+ * literally starts with the directory path, or the directory path starts with
+ * the pattern's literal (pre-glob) prefix.
+ */
+function needsExpansion(patterns, dir) {
+    return patterns.some((p) => {
+        if (p.negated)
+            return false;
+        if (p.raw.startsWith(dir + "/"))
+            return true;
+        const globIdx = p.raw.search(/[*?[]/);
+        if (globIdx > 0 && dir.startsWith(p.raw.slice(0, globIdx)))
+            return true;
+        return false;
+    });
+}
+// --- Post-creation setup -----------------------------------------------------
+/**
+ * Copy <repoRoot>/.wave/settings.local.json into the worktree so local
+ * configuration (permissions, env, ...) carries over. Missing files are
+ * skipped silently; other failures only log a warning.
+ */
+async function copyLocalSettingsToWorktree(repoRoot, worktreePath) {
+    const relativePath = path.join(".wave", "settings.local.json");
+    const sourcePath = path.join(repoRoot, relativePath);
+    const destPath = path.join(worktreePath, relativePath);
+    let content;
+    try {
+        content = await fs.promises.readFile(sourcePath, "utf8");
+    }
+    catch (error) {
+        if (error.code !== "ENOENT") {
+            logger.warn(`Failed to read ${sourcePath}: ${error.message}`);
+        }
+        return;
+    }
+    try {
+        await fs.promises.mkdir(path.dirname(destPath), { recursive: true });
+        await fs.promises.writeFile(destPath, content);
+    }
+    catch (error) {
+        logger.warn(`Failed to copy ${relativePath} into worktree: ${error.message}`);
+    }
+}
+/**
+ * Copy files listed in <repoRoot>/.worktreeinclude into the worktree. Each
+ * non-comment line is a gitignore pattern; matching gitignored files are
+ * copied at their relative paths.
+ */
+async function copyWorktreeIncludeFiles(repoRoot, worktreePath) {
+    const includePath = path.join(repoRoot, ".worktreeinclude");
+    let content;
+    try {
+        content = await fs.promises.readFile(includePath, "utf8");
+    }
+    catch {
+        return [];
+    }
+    const patterns = parseWorktreeIncludePatterns(content);
+    if (patterns.length === 0)
+        return [];
+    const worktreeRelPath = path
+        .relative(repoRoot, worktreePath)
+        .split(path.sep)
+        .join("/");
+    // The worktree lives under .wave/worktrees/, which is gitignored — never
+    // copy the worktree (or anything inside it) into itself.
+    const isSelf = (entry) => entry === worktreeRelPath || entry.startsWith(worktreeRelPath + "/");
+    // "--directory" collapses fully-ignored directories into single entries,
+    // which keeps the listing fast on large repos.
+    let entries;
+    try {
+        const { stdout } = await execFileAsync("git", [
+            "ls-files",
+            "--others",
+            "--ignored",
+            "--exclude-standard",
+            "--directory",
+        ], { cwd: repoRoot, encoding: "utf8" });
+        entries = stdout.trim().split("\n").filter(Boolean);
+    }
+    catch {
+        return [];
+    }
+    const copied = [];
+    const dirsToExpand = [];
+    const copyToWorktree = async (relativePath) => {
+        const srcPath = path.join(repoRoot, relativePath);
+        const destPath = path.join(worktreePath, relativePath);
+        try {
+            await fs.promises.mkdir(path.dirname(destPath), { recursive: true });
+            await fs.promises.copyFile(srcPath, destPath);
+            copied.push(relativePath);
+        }
+        catch (error) {
+            logger.warn(`Failed to copy ${relativePath} into worktree: ${error.message}`);
+        }
+    };
+    for (const entry of entries) {
+        if (isSelf(entry))
+            continue;
+        if (entry.endsWith("/")) {
+            const dir = entry.slice(0, -1);
+            if (worktreeIncludeMatches(patterns, dir, true)) {
+                // The directory itself matches — copy it wholesale
+                try {
+                    await fs.promises.cp(path.join(repoRoot, dir), path.join(worktreePath, dir), {
+                        recursive: true,
+                    });
+                    copied.push(entry);
+                }
+                catch (error) {
+                    logger.warn(`Failed to copy ${entry} into worktree: ${error.message}`);
+                }
+            }
+            else if (needsExpansion(patterns, dir)) {
+                dirsToExpand.push(dir);
+            }
+        }
+        else if (worktreeIncludeMatches(patterns, entry, false)) {
+            await copyToWorktree(entry);
+        }
+    }
+    if (dirsToExpand.length > 0) {
+        // List the files inside collapsed dirs whose contents are targeted
+        try {
+            const { stdout } = await execFileAsync("git", [
+                "ls-files",
+                "--others",
+                "--ignored",
+                "--exclude-standard",
+                "--",
+                ...dirsToExpand,
+            ], { cwd: repoRoot, encoding: "utf8" });
+            for (const file of stdout.trim().split("\n").filter(Boolean)) {
+                if (isSelf(file))
+                    continue;
+                if (worktreeIncludeMatches(patterns, file, false)) {
+                    await copyToWorktree(file);
+                }
+            }
+        }
+        catch {
+            // Expansion is best-effort; the worktree is already usable without it
+        }
+    }
+    return copied;
+}
+/**
+ * Set up a freshly created worktree: copy local settings and gitignored
+ * project files (via .worktreeinclude) from the main repo. Best-effort — any
+ * failure only logs a warning and never fails worktree creation.
+ */
+export async function performPostCreationSetup(worktreePath, repoRoot) {
+    await copyLocalSettingsToWorktree(repoRoot, worktreePath);
+    await copyWorktreeIncludeFiles(repoRoot, worktreePath);
+}
 /**
  * Remove a git worktree and its branch.
  */
@@ -273,6 +560,57 @@ export function removeWorktree(info) {
         throw error;
     }
 }
+/**
+ * Validate that a worktree path is safe to remove before running git removal.
+ * Aligns with Claude Code v2.1.216+ background-session checks:
+ * - rejects a path whose final component is a symlink;
+ * - rejects a path that resolves outside the repo root.
+ *
+ * A path that no longer exists (worktree already removed) is allowed so that
+ * removal stays best-effort/idempotent; its nearest existing ancestor is used
+ * for the containment check. Throws an Error on invalid paths.
+ */
+export function validateWorktreeRemovalPath(worktreePath, repoRoot) {
+    const SYMLINK_PREFIX = "Refusing to remove worktree at symlink path:";
+    // Reject a symlink as the final path component.
+    try {
+        if (fs.lstatSync(worktreePath).isSymbolicLink()) {
+            throw new Error(`${SYMLINK_PREFIX} ${worktreePath}`);
+        }
+    }
+    catch (error) {
+        if (error instanceof Error && error.message.startsWith(SYMLINK_PREFIX)) {
+            throw error;
+        }
+        // lstat failed (path missing) — the containment check below still applies.
+    }
+    const resolvedRepoRoot = fs.realpathSync(repoRoot);
+    // Resolve the path, following symlinks in existing components. If the path
+    // (or a parent) no longer exists, fall back to the deepest existing ancestor
+    // so the containment check still guards against traversal outside the repo.
+    let resolvedPath;
+    let existingAncestor = worktreePath;
+    for (;;) {
+        try {
+            resolvedPath = fs.realpathSync(existingAncestor);
+            break;
+        }
+        catch {
+            const parent = path.dirname(existingAncestor);
+            if (parent === existingAncestor) {
+                throw new Error(`Invalid worktree path for removal: ${worktreePath}`);
+            }
+            existingAncestor = parent;
+        }
+    }
+    if (existingAncestor !== worktreePath) {
+        resolvedPath = path.join(resolvedPath, path.relative(existingAncestor, worktreePath));
+    }
+    const relative = path.relative(resolvedRepoRoot, resolvedPath);
+    if (relative.startsWith("..") || path.isAbsolute(relative)) {
+        throw new Error(`Refusing to remove worktree outside repo root: ${worktreePath}`);
+    }
+}
 /**
  * Count uncommitted files and new commits in a worktree.
  * Returns null if git commands fail (fail-closed).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wave-agent-sdk",
-  "version": "0.19.9",
+  "version": "1.0.1",
   "description": "SDK for building AI-powered development tools and agents",
   "keywords": [
     "ai",