@co0ontty/wand 3.1.1 → 4.0.0

package/dist/provider-history-scanner.d.ts

@@ -0,0 +1,54 @@
+export interface ClaudeHistorySession {
+    claudeSessionId: string;
+    projectDir: string;
+    cwd: string;
+    firstUserMessage: string;
+    timestamp: string;
+    mtimeMs: number;
+    hasConversation: boolean;
+    managedByWand: boolean;
+}
+export interface CodexHistorySession {
+    claudeSessionId: string;
+    cwd: string;
+    firstUserMessage: string;
+    firstUserAt: string;
+    timestamp: string;
+    mtimeMs: number;
+    hasUser: boolean;
+    hasConversation: boolean;
+    managedByWand: boolean;
+    provider: "codex";
+}
+export interface ProviderHistoryScannerOptions {
+    claudeHome?: string;
+    codexSessionsDir?: string;
+}
+/**
+ * Incremental provider-history index. Directory entries are refreshed on each
+ * scan, while unchanged JSONL heads are reused by (path, mtime, size).
+ */
+export declare class ProviderHistoryScanner {
+    private readonly claudeHome;
+    private readonly claudeProjectsDir;
+    private readonly codexSessionsDir;
+    private readonly claudeIndex;
+    private readonly codexIndex;
+    private parsedFiles;
+    constructor(options?: ProviderHistoryScannerOptions);
+    getDiagnostics(): {
+        parsedFiles: number;
+        claudeEntries: number;
+        codexEntries: number;
+    };
+    invalidate(provider?: "claude" | "codex"): void;
+    listClaudeHistorySessions(): ClaudeHistorySession[];
+    private listCodexRolloutFiles;
+    listCodexHistorySessions(): CodexHistorySession[];
+    hasCodexSessionFile(threadId: string): boolean;
+    deleteClaudeHistoryFiles(sessions: Array<{
+        claudeSessionId: string;
+        cwd: string;
+    }>): number;
+    deleteCodexHistoryFiles(threadIds: string[]): number;
+}

package/dist/provider-history-scanner.js

@@ -0,0 +1,354 @@
+import { closeSync, existsSync, openSync, readSync, readdirSync, rmSync, statSync, unlinkSync, } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const WORKTREE_DIR_PATTERN = /--?\.?(?:wand-worktrees|claude-worktrees)-/;
+function readHead(filePath, maxBytes) {
+    let fd = null;
+    try {
+        const stats = statSync(filePath);
+        fd = openSync(filePath, "r");
+        const buffer = Buffer.alloc(Math.min(maxBytes, Math.max(1, stats.size)));
+        const bytesRead = readSync(fd, buffer, 0, buffer.length, 0);
+        return { text: buffer.toString("utf8", 0, bytesRead), mtimeMs: stats.mtimeMs, size: stats.size };
+    }
+    catch {
+        return null;
+    }
+    finally {
+        if (fd !== null) {
+            try {
+                closeSync(fd);
+            }
+            catch { /* best effort */ }
+        }
+    }
+}
+/** Best-effort inverse of Claude's non-alphanumeric-to-dash project encoding. */
+function invertNormalizedProjectDir(dirName) {
+    const naive = dirName.replace(/-/g, "/");
+    if (existsSync(naive))
+        return naive;
+    const parts = dirName.split("-").filter(Boolean);
+    if (parts.length === 0 || parts.length > 20)
+        return naive;
+    let candidates = ["/" + parts[0]];
+    for (let index = 1; index < parts.length; index += 1) {
+        const next = [];
+        for (const prefix of candidates) {
+            next.push(`${prefix}/${parts[index]}`);
+            next.push(`${prefix}-${parts[index]}`);
+        }
+        if (index < parts.length - 1) {
+            const valid = next.filter((candidate) => {
+                try {
+                    return existsSync(candidate);
+                }
+                catch {
+                    return false;
+                }
+            });
+            candidates = valid.length > 0 ? valid : next;
+        }
+        else {
+            candidates = next;
+        }
+        if (candidates.length > 200)
+            candidates = candidates.slice(0, 200);
+    }
+    return candidates.find((candidate) => existsSync(candidate)) ?? candidates[0] ?? naive;
+}
+function parseClaudeSummary(filePath, id, cwd, head) {
+    let timestamp = "";
+    let firstUserMessage = "";
+    let hasUser = false;
+    let hasAssistant = false;
+    for (const line of head.text.split("\n")) {
+        if (!line.trim())
+            continue;
+        try {
+            const parsed = JSON.parse(line);
+            if (!timestamp && parsed.timestamp)
+                timestamp = parsed.timestamp;
+            if (parsed.type === "user" || parsed.message?.role === "user") {
+                hasUser = true;
+                const content = typeof parsed.content === "string"
+                    ? parsed.content
+                    : typeof parsed.message?.content === "string"
+                        ? parsed.message.content
+                        : "";
+                if (!firstUserMessage && content.trim())
+                    firstUserMessage = content.trim().slice(0, 120);
+            }
+            if (parsed.type === "assistant" || parsed.message?.role === "assistant")
+                hasAssistant = true;
+        }
+        catch {
+            continue;
+        }
+    }
+    return {
+        claudeSessionId: id,
+        projectDir: path.basename(path.dirname(filePath)),
+        cwd,
+        firstUserMessage,
+        timestamp: timestamp || new Date(head.mtimeMs).toISOString(),
+        mtimeMs: head.mtimeMs,
+        hasConversation: hasUser && hasAssistant,
+        managedByWand: false,
+    };
+}
+function isCodexSystemInjectedText(text) {
+    const trimmed = text.trimStart();
+    return trimmed.startsWith("#") || trimmed.startsWith("<");
+}
+function parseCodexSummary(head) {
+    let id = "";
+    let cwd = "";
+    let timestamp = "";
+    let firstUserMessage = "";
+    let firstUserAt = "";
+    let hasUser = false;
+    let hasAssistant = false;
+    for (const line of head.text.split("\n")) {
+        if (!line.trim())
+            continue;
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (!timestamp && parsed.timestamp)
+            timestamp = parsed.timestamp;
+        const payload = parsed.payload;
+        if (!payload)
+            continue;
+        if (parsed.type === "session_meta" || payload.type === "session_meta") {
+            if (!id && typeof payload.id === "string")
+                id = payload.id;
+            if (!cwd && typeof payload.cwd === "string")
+                cwd = payload.cwd;
+            continue;
+        }
+        if (payload.type === "message" && payload.role === "user") {
+            const text = Array.isArray(payload.content)
+                ? payload.content
+                    .filter((block) => block?.type === "input_text" && typeof block.text === "string")
+                    .map((block) => block.text)
+                    .join("")
+                : "";
+            if (text.trim()) {
+                hasUser = true;
+                if (!firstUserAt && parsed.timestamp)
+                    firstUserAt = parsed.timestamp;
+                if (!firstUserMessage && !isCodexSystemInjectedText(text))
+                    firstUserMessage = text.trim().slice(0, 120);
+            }
+        }
+        else if (payload.type === "message" && payload.role === "assistant") {
+            hasAssistant = true;
+        }
+    }
+    if (!id)
+        return null;
+    return {
+        claudeSessionId: id,
+        cwd,
+        firstUserMessage,
+        firstUserAt,
+        timestamp: timestamp || new Date(head.mtimeMs).toISOString(),
+        mtimeMs: head.mtimeMs,
+        hasUser,
+        hasConversation: hasUser && hasAssistant,
+        managedByWand: false,
+        provider: "codex",
+    };
+}
+/**
+ * Incremental provider-history index. Directory entries are refreshed on each
+ * scan, while unchanged JSONL heads are reused by (path, mtime, size).
+ */
+export class ProviderHistoryScanner {
+    claudeHome;
+    claudeProjectsDir;
+    codexSessionsDir;
+    claudeIndex = new Map();
+    codexIndex = new Map();
+    parsedFiles = 0;
+    constructor(options = {}) {
+        this.claudeHome = options.claudeHome ?? path.join(os.homedir(), ".claude");
+        this.claudeProjectsDir = path.join(this.claudeHome, "projects");
+        this.codexSessionsDir = options.codexSessionsDir ?? path.join(os.homedir(), ".codex", "sessions");
+    }
+    getDiagnostics() {
+        return { parsedFiles: this.parsedFiles, claudeEntries: this.claudeIndex.size, codexEntries: this.codexIndex.size };
+    }
+    invalidate(provider) {
+        if (!provider || provider === "claude")
+            this.claudeIndex.clear();
+        if (!provider || provider === "codex")
+            this.codexIndex.clear();
+    }
+    listClaudeHistorySessions() {
+        const observed = new Set();
+        const results = [];
+        let dirs;
+        try {
+            dirs = readdirSync(this.claudeProjectsDir, { withFileTypes: true });
+        }
+        catch {
+            return [];
+        }
+        for (const dir of dirs) {
+            if (!dir.isDirectory() || WORKTREE_DIR_PATTERN.test(dir.name))
+                continue;
+            const dirPath = path.join(this.claudeProjectsDir, dir.name);
+            const cwd = invertNormalizedProjectDir(dir.name);
+            let files;
+            try {
+                files = readdirSync(dirPath, { withFileTypes: true });
+            }
+            catch {
+                continue;
+            }
+            for (const file of files) {
+                if (!file.isFile() || !file.name.endsWith(".jsonl"))
+                    continue;
+                const id = file.name.slice(0, -6);
+                if (!UUID_PATTERN.test(id))
+                    continue;
+                const filePath = path.join(dirPath, file.name);
+                observed.add(filePath);
+                let stats;
+                try {
+                    stats = statSync(filePath);
+                }
+                catch {
+                    continue;
+                }
+                let cached = this.claudeIndex.get(filePath);
+                if (!cached || cached.mtimeMs !== stats.mtimeMs || cached.size !== stats.size) {
+                    const head = readHead(filePath, 8192);
+                    if (!head)
+                        continue;
+                    cached = { mtimeMs: head.mtimeMs, size: head.size, summary: parseClaudeSummary(filePath, id, cwd, head) };
+                    this.claudeIndex.set(filePath, cached);
+                    this.parsedFiles += 1;
+                }
+                if (cached.summary)
+                    results.push({ ...cached.summary, managedByWand: false });
+            }
+        }
+        for (const filePath of this.claudeIndex.keys()) {
+            if (!observed.has(filePath))
+                this.claudeIndex.delete(filePath);
+        }
+        return results.sort((left, right) => right.mtimeMs - left.mtimeMs);
+    }
+    listCodexRolloutFiles() {
+        try {
+            return readdirSync(this.codexSessionsDir, { recursive: true, withFileTypes: true })
+                .filter((entry) => entry.isFile() && entry.name.startsWith("rollout-") && entry.name.endsWith(".jsonl"))
+                .map((entry) => {
+                const parent = entry.parentPath
+                    ?? entry.path
+                    ?? this.codexSessionsDir;
+                return path.join(parent, entry.name);
+            });
+        }
+        catch {
+            return [];
+        }
+    }
+    listCodexHistorySessions() {
+        const observed = new Set();
+        const byThread = new Map();
+        for (const filePath of this.listCodexRolloutFiles()) {
+            observed.add(filePath);
+            let stats;
+            try {
+                stats = statSync(filePath);
+            }
+            catch {
+                continue;
+            }
+            let cached = this.codexIndex.get(filePath);
+            if (!cached || cached.mtimeMs !== stats.mtimeMs || cached.size !== stats.size) {
+                const head = readHead(filePath, 65536);
+                if (!head)
+                    continue;
+                cached = { mtimeMs: head.mtimeMs, size: head.size, summary: parseCodexSummary(head) };
+                this.codexIndex.set(filePath, cached);
+                this.parsedFiles += 1;
+            }
+            const summary = cached.summary;
+            if (!summary)
+                continue;
+            const existing = byThread.get(summary.claudeSessionId);
+            if (!existing || summary.mtimeMs > existing.mtimeMs) {
+                byThread.set(summary.claudeSessionId, { ...summary, managedByWand: false });
+            }
+        }
+        for (const filePath of this.codexIndex.keys()) {
+            if (!observed.has(filePath))
+                this.codexIndex.delete(filePath);
+        }
+        return Array.from(byThread.values()).sort((left, right) => right.mtimeMs - left.mtimeMs);
+    }
+    hasCodexSessionFile(threadId) {
+        return UUID_PATTERN.test(threadId)
+            && this.listCodexHistorySessions().some((session) => session.claudeSessionId === threadId);
+    }
+    deleteClaudeHistoryFiles(sessions) {
+        let deleted = 0;
+        for (const { claudeSessionId, cwd } of sessions) {
+            if (!UUID_PATTERN.test(claudeSessionId))
+                continue;
+            const normalized = path.resolve(cwd).replace(/[^a-zA-Z0-9]/g, "-");
+            const jsonlPath = path.join(this.claudeProjectsDir, normalized, `${claudeSessionId}.jsonl`);
+            try {
+                unlinkSync(jsonlPath);
+                deleted += 1;
+            }
+            catch { /* already absent */ }
+            this.claudeIndex.delete(jsonlPath);
+            for (const sub of ["session-env", "tasks", "todos"]) {
+                const dir = path.join(this.claudeHome, sub, claudeSessionId);
+                try {
+                    if (existsSync(dir))
+                        rmSync(dir, { recursive: true, force: true });
+                }
+                catch { /* best effort */ }
+            }
+        }
+        return deleted;
+    }
+    deleteCodexHistoryFiles(threadIds) {
+        const valid = new Set(threadIds.filter((id) => UUID_PATTERN.test(id)));
+        if (valid.size === 0)
+            return 0;
+        let deleted = 0;
+        for (const filePath of this.listCodexRolloutFiles()) {
+            let cached = this.codexIndex.get(filePath);
+            if (!cached) {
+                const head = readHead(filePath, 65536);
+                if (!head)
+                    continue;
+                cached = { mtimeMs: head.mtimeMs, size: head.size, summary: parseCodexSummary(head) };
+                this.codexIndex.set(filePath, cached);
+                this.parsedFiles += 1;
+            }
+            if (cached.summary && valid.has(cached.summary.claudeSessionId)) {
+                try {
+                    unlinkSync(filePath);
+                    deleted += 1;
+                }
+                catch { /* already absent */ }
+                this.codexIndex.delete(filePath);
+            }
+        }
+        return deleted;
+    }
+}

package/dist/request-limits.d.ts

@@ -0,0 +1 @@
+export declare function parseBoundedInteger(value: unknown, fallback: number, minimum: number, maximum: number): number;

package/dist/request-limits.js

@@ -0,0 +1,8 @@
+export function parseBoundedInteger(value, fallback, minimum, maximum) {
+    if (typeof value !== "string" || !/^-?\d+$/.test(value.trim()))
+        return fallback;
+    const parsed = Number(value);
+    if (!Number.isSafeInteger(parsed))
+        return fallback;
+    return Math.min(Math.max(parsed, minimum), maximum);
+}

package/dist/resume-policy.d.ts

@@ -1,2 +1,4 @@
+/** Claude session IDs and Codex thread IDs are UUID-shaped identifiers. */
+export declare function isProviderSessionId(value: unknown): value is string;
 export declare function getResumeCommandSessionId(command: string): string | null;
 export declare function getCodexResumeCommandSessionId(command: string): string | null;

package/dist/resume-policy.js

@@ -1,6 +1,11 @@
 const UUID_PATTERN = "[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}";
+const PROVIDER_SESSION_ID_PATTERN = new RegExp(`^${UUID_PATTERN}$`, "i");
 const RESUME_COMMAND_ID_PATTERN = new RegExp(`(?:^|\\s)--resume\\s+(${UUID_PATTERN})(?:\\s|$)`, "i");
 const CODEX_RESUME_COMMAND_ID_PATTERN = new RegExp(`(?:^|\\s)resume\\s+(${UUID_PATTERN})(?:\\s|$)`, "i");
+/** Claude session IDs and Codex thread IDs are UUID-shaped identifiers. */
+export function isProviderSessionId(value) {
+    return typeof value === "string" && PROVIDER_SESSION_ID_PATTERN.test(value);
+}
 export function getResumeCommandSessionId(command) {
     const match = RESUME_COMMAND_ID_PATTERN.exec(command);
     return match?.[1] ?? null;

package/dist/runtime-config.d.ts

@@ -0,0 +1,16 @@
+import type { PreferenceKey } from "./config.js";
+import type { WandConfig } from "./types.js";
+export declare const DEPLOYMENT_CONFIG_KEYS: readonly ["host", "port", "https", "shell"];
+export type DeploymentConfigKey = (typeof DEPLOYMENT_CONFIG_KEYS)[number];
+/** Keeps the active process configuration separate from values persisted for the next restart. */
+export declare class RuntimeConfigState {
+    readonly activeConfig: WandConfig;
+    private desiredConfig;
+    constructor(activeConfig: WandConfig);
+    desiredSnapshot(): WandConfig;
+    createCandidate(): WandConfig;
+    commit(candidate: WandConfig, hotPreferenceKeys: Iterable<PreferenceKey>): void;
+    hasPendingRestart(candidate?: WandConfig): boolean;
+    activeDeployment(): Pick<WandConfig, DeploymentConfigKey>;
+    desiredDeployment(candidate?: WandConfig): Pick<WandConfig, DeploymentConfigKey>;
+}

package/dist/runtime-config.js

@@ -0,0 +1,49 @@
+export const DEPLOYMENT_CONFIG_KEYS = ["host", "port", "https", "shell"];
+function cloneConfig(config) {
+    return structuredClone(config);
+}
+/** Keeps the active process configuration separate from values persisted for the next restart. */
+export class RuntimeConfigState {
+    activeConfig;
+    desiredConfig;
+    constructor(activeConfig) {
+        this.activeConfig = activeConfig;
+        this.desiredConfig = cloneConfig(activeConfig);
+    }
+    desiredSnapshot() {
+        return cloneConfig(this.desiredConfig);
+    }
+    createCandidate() {
+        return this.desiredSnapshot();
+    }
+    commit(candidate, hotPreferenceKeys) {
+        this.desiredConfig = cloneConfig(candidate);
+        for (const key of hotPreferenceKeys) {
+            this.activeConfig[key] = cloneConfigValue(candidate[key]);
+        }
+    }
+    hasPendingRestart(candidate = this.desiredConfig) {
+        return DEPLOYMENT_CONFIG_KEYS.some((key) => candidate[key] !== this.activeConfig[key]);
+    }
+    activeDeployment() {
+        return {
+            host: this.activeConfig.host,
+            port: this.activeConfig.port,
+            https: this.activeConfig.https,
+            shell: this.activeConfig.shell,
+        };
+    }
+    desiredDeployment(candidate = this.desiredConfig) {
+        return {
+            host: candidate.host,
+            port: candidate.port,
+            https: candidate.https,
+            shell: candidate.shell,
+        };
+    }
+}
+function cloneConfigValue(value) {
+    if (value === undefined || value === null || typeof value !== "object")
+        return value;
+    return structuredClone(value);
+}

package/dist/server-file-routes.d.ts

@@ -0,0 +1,17 @@
+import type { Express, Request, Response } from "express";
+import type { WandStorage } from "./storage.js";
+export interface ServerFileRoutesDependencies {
+    storage: WandStorage;
+    defaultCwd: string;
+}
+/** Persist a cwd to recent paths. Used by REST and session creation hooks. */
+export declare function recordRecentPath(storage: WandStorage, cwd: string | undefined | null): void;
+export declare function registerFileRoutes(app: Express, deps: ServerFileRoutesDependencies): void;
+export declare function streamFileWithRange(req: Request, res: Response, options: {
+    filePath: string;
+    size: number;
+    contentType: string;
+    disposition?: string;
+    headers?: Record<string, string>;
+    readErrorMessage?: string;
+}): void;