codeep 3.3.3 → 3.4.1

package/dist/config/index.d.ts

@@ -291,8 +291,16 @@ export declare function resolveBaseUrl(providerId: string, protocol: 'openai' |
 export { PROVIDERS } from './providers';
 export declare function getCurrentSessionId(): string;
 export declare function startNewSession(): string;
-export declare function autoSaveSession(history: Message[], projectPath?: string): boolean;
+export declare function autoSaveSession(history: Message[], projectPath?: string, sessionId?: string): boolean;
 export declare function flushAutoSave(): boolean;
+/**
+ * Why a session name cannot be used, or null when it can. A session is kept
+ * as <name>.json inside the sessions directory, so a name holding a path
+ * separator (`../../x`, `feature/auth`) would read or write a file elsewhere.
+ * A backslash is a separator only on Windows; elsewhere it is an ordinary
+ * filename character, and sessions named with one already exist.
+ */
+export declare function sessionNameProblem(name: string): string | null;
 export declare function saveSession(name: string, history: Message[], projectPath?: string): boolean;
 /**
  * Generate and persist an AI title for a session, if it doesn't have
@@ -303,6 +311,13 @@ export declare function maybeGenerateSessionTitle(name: string, projectPath?: st
 export declare function loadSession(name: string, projectPath?: string): Message[] | null;
 export declare function listSessions(projectPath?: string): string[];
 export declare function deleteSession(name: string, projectPath?: string): boolean;
+/**
+ * True when `name` already belongs to a saved conversation other than
+ * `currentName`'s. A name differing only in case can resolve to the same file
+ * on a case-insensitive disk; that is the same conversation, not a clash.
+ * Inodes are compared as bigints: on Windows they can exceed 2^53.
+ */
+export declare function sessionNameTaken(name: string, currentName: string, projectPath?: string): boolean;
 export declare function renameSession(oldName: string, newName: string, projectPath?: string): boolean;
 export declare function getSessionInfo(name: string, projectPath?: string): {
     name: string;
@@ -321,15 +336,17 @@ export interface SessionInfo {
  */
 export declare function listSessionsWithInfo(projectPath?: string): SessionInfo[];
 /**
- * Get project permission from local .codeep/config.json or global config
+ * Get the permission the user granted for a project.
  */
 export declare function getProjectPermission(projectPath: string): ProjectPermission | null;
 /**
- * Set project permission in local .codeep/config.json or global config
+ * Record a permission grant in the global config.
  */
 export declare function setProjectPermission(projectPath: string, read: boolean, write: boolean): void;
 /**
- * Remove project permission from local .codeep/config.json or global config
+ * Remove a project's permission from the global config. A grant an older
+ * version wrote into the project for this same directory is removed too, so
+ * it does not linger in a file that may be committed.
  */
 export declare function removeProjectPermission(projectPath: string): boolean;
 export declare function hasReadPermission(projectPath: string): boolean;

package/dist/config/index.js

@@ -1,10 +1,11 @@
 import Conf from 'conf';
-import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync, unlinkSync, statSync } from 'fs';
-import { join, dirname } from 'path';
+import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync, unlinkSync, statSync, renameSync } from 'fs';
+import { join, dirname, resolve, sep, isAbsolute } from 'path';
 import { randomUUID } from 'crypto';
 import { PROVIDERS, getProvider, getProviderBaseUrl, replacementModelFor } from './providers.js';
 import { logSession } from '../utils/logger.js';
 import { createSecureStorage } from '../utils/keychain.js';
+import { isSafeProjectDir, leadsOutsideProject, writeFileNoFollow, writeProjectFile } from '../utils/projectPaths.js';
 // We'll initialize GLOBAL_SESSIONS_DIR after config is created (to use config.path)
 /**
  * Get sessions directory - local .codeep/sessions/ if in project, otherwise global
@@ -12,25 +13,17 @@ import { createSecureStorage } from '../utils/keychain.js';
 export function getSessionsDir(projectPath) {
     if (projectPath && isProjectDirectory(projectPath)) {
         const localDir = join(projectPath, '.codeep', 'sessions');
-        if (!existsSync(localDir)) {
-            mkdirSync(localDir, { recursive: true });
+        // .codeep/ can come with a cloned repo; a symlinked sessions directory
+        // would have every save written wherever it points.
+        if (isSafeProjectDir(projectPath, localDir)) {
+            if (!existsSync(localDir)) {
+                mkdirSync(localDir, { recursive: true });
+            }
+            return localDir;
         }
-        return localDir;
     }
     return GLOBAL_SESSIONS_DIR;
 }
-/**
- * Get local project config path
- */
-function getLocalConfigPath(projectPath) {
-    if (!isProjectDirectory(projectPath))
-        return null;
-    const configDir = join(projectPath, '.codeep');
-    if (!existsSync(configDir)) {
-        mkdirSync(configDir, { recursive: true });
-    }
-    return join(configDir, 'config.json');
-}
 /**
  * Check if directory is a project
  * Looks for common project indicators: package.json, pyproject.toml, Cargo.toml, go.mod, composer.json, etc.
@@ -80,17 +73,13 @@ export function hasStandardProjectMarkers(path) {
  */
 export function initializeAsProject(path) {
     try {
-        const codeepDir = join(path, '.codeep');
-        if (!existsSync(codeepDir)) {
-            mkdirSync(codeepDir, { recursive: true });
-        }
-        const projectFile = join(codeepDir, 'project.json');
+        const projectFile = join(path, '.codeep', 'project.json');
         const projectData = {
             name: path.split('/').pop() || 'project',
             initializedAt: new Date().toISOString(),
             version: '1.0',
         };
-        writeFileSync(projectFile, JSON.stringify(projectData, null, 2));
+        writeProjectFile(path, projectFile, JSON.stringify(projectData, null, 2));
         return true;
     }
     catch {
@@ -821,46 +810,87 @@ export function startNewSession() {
     config.set('currentSessionId', sessionId);
     return sessionId;
 }
-// Auto-save debounce state
+// Auto-save debounce state. The target session is fixed when the save is
+// requested, not when the timer fires: by then the user may have loaded or
+// started another conversation, and this history would overwrite its file.
 let autoSaveTimeout = null;
 let pendingAutoSave = null;
-// Auto-save current session (debounced - saves max every 5 seconds)
-export function autoSaveSession(history, projectPath) {
+function writePendingAutoSave() {
+    if (!pendingAutoSave)
+        return false;
+    const { sessionId, history, projectPath } = pendingAutoSave;
+    pendingAutoSave = null;
+    return saveSession(sessionId, history, projectPath);
+}
+// Auto-save a conversation (debounced - saves max every 5 seconds).
+// Pass the id of the conversation the history belongs to. The global
+// currentSessionId is only the fallback: it names one conversation, and
+// callers holding another (a loaded session, a second ACP thread) would
+// otherwise save over it.
+export function autoSaveSession(history, projectPath, sessionId) {
     if (!config.get('autoSave') || history.length === 0) {
         return false;
     }
-    // Store pending save data
-    pendingAutoSave = { history, projectPath };
+    const target = sessionId || getCurrentSessionId();
+    // Only one save is held back at a time. One queued for a different
+    // conversation would be dropped by the overwrite below, so write it now.
+    if (pendingAutoSave && (pendingAutoSave.sessionId !== target || pendingAutoSave.projectPath !== projectPath)) {
+        writePendingAutoSave();
+    }
+    pendingAutoSave = { history, projectPath, sessionId: target };
     // If already scheduled, don't reschedule
     if (autoSaveTimeout) {
         return true;
     }
     // Schedule save after 5 seconds
     autoSaveTimeout = setTimeout(() => {
-        if (pendingAutoSave) {
-            const sessionId = getCurrentSessionId();
-            saveSession(sessionId, pendingAutoSave.history, pendingAutoSave.projectPath);
-            pendingAutoSave = null;
-        }
         autoSaveTimeout = null;
+        writePendingAutoSave();
     }, 5000);
     return true;
 }
-// Force immediate save (for explicit save commands)
+// Write any debounced save now. Anything about to exit must call this: the
+// 5-second timer never fires once the process is gone.
 export function flushAutoSave() {
     if (autoSaveTimeout) {
         clearTimeout(autoSaveTimeout);
         autoSaveTimeout = null;
     }
-    if (pendingAutoSave) {
-        const sessionId = getCurrentSessionId();
-        const result = saveSession(sessionId, pendingAutoSave.history, pendingAutoSave.projectPath);
-        pendingAutoSave = null;
-        return result;
-    }
-    return false;
+    return writePendingAutoSave();
 }
 // Session management
+/**
+ * Why a session name cannot be used, or null when it can. A session is kept
+ * as <name>.json inside the sessions directory, so a name holding a path
+ * separator (`../../x`, `feature/auth`) would read or write a file elsewhere.
+ * A backslash is a separator only on Windows; elsewhere it is an ordinary
+ * filename character, and sessions named with one already exist.
+ */
+export function sessionNameProblem(name) {
+    if (!name || !name.trim())
+        return 'Session name cannot be empty.';
+    if (sep === '\\') {
+        if (/[\/\\]/.test(name))
+            return `Session name "${name}" cannot contain "/" or "\\".`;
+    }
+    else if (name.includes('/')) {
+        return `Session name "${name}" cannot contain "/".`;
+    }
+    // eslint-disable-next-line no-control-regex
+    if (/[\x00-\x1f]/.test(name))
+        return 'Session name cannot contain control characters.';
+    if (name === '.' || name === '..')
+        return `Session name "${name}" is not allowed.`;
+    return null;
+}
+/** The file a session is kept in, or null for a name that would leave the sessions directory. */
+function sessionFile(name, projectPath) {
+    if (sessionNameProblem(name))
+        return null;
+    const sessionsDir = getSessionsDir(projectPath);
+    const filePath = join(sessionsDir, `${name}.json`);
+    return dirname(resolve(filePath)) === resolve(sessionsDir) ? filePath : null;
+}
 export function saveSession(name, history, projectPath) {
     try {
         // Derive a human-readable title from the first user message
@@ -868,8 +898,11 @@ export function saveSession(name, history, projectPath) {
         const title = firstUserMsg
             ? firstUserMsg.content.replace(/\n/g, ' ').trim().slice(0, 60)
             : name;
-        const sessionsDir = getSessionsDir(projectPath);
-        const filePath = join(sessionsDir, `${name}.json`);
+        const filePath = sessionFile(name, projectPath);
+        if (!filePath) {
+            logSession('save', name, false);
+            return false;
+        }
         // Preserve an existing aiTitle across re-saves so we don't regenerate.
         let existingAiTitle;
         if (existsSync(filePath)) {
@@ -886,7 +919,7 @@ export function saveSession(name, history, projectPath) {
             history,
             createdAt: new Date().toISOString(),
         };
-        writeFileSync(filePath, JSON.stringify(session, null, 2));
+        writeFileNoFollow(filePath, JSON.stringify(session, null, 2));
         logSession('save', name, true);
         // Fire-and-forget: generate an AI title once the session has enough
         // content. The orchestrator early-returns if one already exists, so
@@ -926,9 +959,8 @@ const titlesInFlight = new Set();
 export async function maybeGenerateSessionTitle(name, projectPath) {
     if (titlesInFlight.has(name))
         return;
-    const sessionsDir = getSessionsDir(projectPath);
-    const filePath = join(sessionsDir, `${name}.json`);
-    if (!existsSync(filePath))
+    const filePath = sessionFile(name, projectPath);
+    if (!filePath || !existsSync(filePath))
         return;
     let data;
     try {
@@ -949,7 +981,7 @@ export async function maybeGenerateSessionTitle(name, projectPath) {
             try {
                 const fresh = JSON.parse(readFileSync(filePath, 'utf-8'));
                 fresh.aiTitle = aiTitle;
-                writeFileSync(filePath, JSON.stringify(fresh, null, 2));
+                writeFileNoFollow(filePath, JSON.stringify(fresh, null, 2));
             }
             catch { /* ignore */ }
         }
@@ -960,9 +992,8 @@ export async function maybeGenerateSessionTitle(name, projectPath) {
 }
 export function loadSession(name, projectPath) {
     try {
-        const sessionsDir = getSessionsDir(projectPath);
-        const filePath = join(sessionsDir, `${name}.json`);
-        if (existsSync(filePath)) {
+        const filePath = sessionFile(name, projectPath);
+        if (filePath && existsSync(filePath)) {
             const data = JSON.parse(readFileSync(filePath, 'utf-8'));
             logSession('load', name, true);
             return data.history;
@@ -989,9 +1020,8 @@ export function listSessions(projectPath) {
 }
 export function deleteSession(name, projectPath) {
     try {
-        const sessionsDir = getSessionsDir(projectPath);
-        const filePath = join(sessionsDir, `${name}.json`);
-        if (existsSync(filePath)) {
+        const filePath = sessionFile(name, projectPath);
+        if (filePath && existsSync(filePath)) {
             unlinkSync(filePath);
             logSession('delete', name, true);
             return true;
@@ -1004,26 +1034,72 @@ export function deleteSession(name, projectPath) {
         return false;
     }
 }
+/**
+ * True when `name` already belongs to a saved conversation other than
+ * `currentName`'s. A name differing only in case can resolve to the same file
+ * on a case-insensitive disk; that is the same conversation, not a clash.
+ * Inodes are compared as bigints: on Windows they can exceed 2^53.
+ */
+export function sessionNameTaken(name, currentName, projectPath) {
+    if (name === currentName)
+        return false;
+    const target = sessionFile(name, projectPath);
+    if (!target || !existsSync(target))
+        return false;
+    const current = sessionFile(currentName, projectPath);
+    if (!current || !existsSync(current))
+        return true;
+    const a = statSync(target, { bigint: true });
+    const b = statSync(current, { bigint: true });
+    return a.ino !== b.ino || a.dev !== b.dev;
+}
 export function renameSession(oldName, newName, projectPath) {
     try {
         const sessionsDir = getSessionsDir(projectPath);
-        const oldPath = join(sessionsDir, `${oldName}.json`);
-        const newPath = join(sessionsDir, `${newName}.json`);
-        if (!existsSync(oldPath)) {
+        const oldPath = sessionFile(oldName, projectPath);
+        const newPath = sessionFile(newName, projectPath);
+        if (!oldPath || !newPath || !existsSync(oldPath)) {
+            logSession('rename', `${oldName} -> ${newName}`, false);
+            return false;
+        }
+        // Renaming onto itself changes nothing.
+        if (newName === oldName) {
+            logSession('rename', `${oldName} -> ${newName}`, true);
+            return true;
+        }
+        // Never replace another saved conversation: it would be gone for good.
+        if (sessionNameTaken(newName, oldName, projectPath)) {
             logSession('rename', `${oldName} -> ${newName}`, false);
             return false;
         }
         // Read existing session
         const data = JSON.parse(readFileSync(oldPath, 'utf-8'));
-        // Update name and save to new path
         data.name = newName;
-        writeFileSync(newPath, JSON.stringify(data, null, 2));
-        // Delete old file
-        unlinkSync(oldPath);
+        // Write the renamed copy aside, move the session, then put the copy in
+        // place. The old file is not touched until the move: writing the new
+        // name into it first left a failed move (`feature/auth`) with a session
+        // that lists under a name it cannot be loaded by. Writing the new path
+        // and unlinking the old one would delete the session when a case-only
+        // rename makes both one file.
+        const staged = join(sessionsDir, `.${randomUUID()}.rename.tmp`);
+        writeFileSync(staged, JSON.stringify(data, null, 2));
+        try {
+            renameSync(oldPath, newPath);
+            renameSync(staged, newPath);
+        }
+        finally {
+            if (existsSync(staged))
+                unlinkSync(staged);
+        }
         // Update current session ID if it was the renamed one
         if (config.get('currentSessionId') === oldName) {
             config.set('currentSessionId', newName);
         }
+        // A debounced save still aimed at the old name would bring the old file
+        // back beside the renamed one.
+        if (pendingAutoSave?.sessionId === oldName && getSessionsDir(pendingAutoSave.projectPath) === sessionsDir) {
+            pendingAutoSave.sessionId = newName;
+        }
         logSession('rename', `${oldName} -> ${newName}`, true);
         return true;
     }
@@ -1034,9 +1110,8 @@ export function renameSession(oldName, newName, projectPath) {
 }
 export function getSessionInfo(name, projectPath) {
     try {
-        const sessionsDir = getSessionsDir(projectPath);
-        const filePath = join(sessionsDir, `${name}.json`);
-        if (existsSync(filePath)) {
+        const filePath = sessionFile(name, projectPath);
+        if (filePath && existsSync(filePath)) {
             const data = JSON.parse(readFileSync(filePath, 'utf-8'));
             return {
                 name: data.name,
@@ -1092,91 +1167,71 @@ export function listSessionsWithInfo(projectPath) {
     }
 }
 // Project permission management
+//
+// Grants live only in the user's global config, which no repository can
+// write. Older versions also stored them in the project's own
+// `.codeep/config.json`; that file can arrive with a cloned repo, and no rule
+// about its contents holds up (a relative `path` resolves against wherever
+// Codeep was started), so a grant there no longer counts. A user who granted
+// access with an older version is asked once more.
+/** The project's own config file, without creating anything. */
+function localConfigFile(projectPath) {
+    return isProjectDirectory(projectPath) ? join(projectPath, '.codeep', 'config.json') : null;
+}
+function grantMatches(perm, projectPath) {
+    return !!perm && typeof perm === 'object'
+        && typeof perm.path === 'string'
+        && isAbsolute(perm.path)
+        && resolve(perm.path) === resolve(projectPath);
+}
 /**
- * Get project permission from local .codeep/config.json or global config
+ * Get the permission the user granted for a project.
  */
 export function getProjectPermission(projectPath) {
-    // First try local .codeep/config.json (for recognized projects)
-    const configPath = getLocalConfigPath(projectPath);
-    if (configPath && existsSync(configPath)) {
-        try {
-            const data = JSON.parse(readFileSync(configPath, 'utf-8'));
-            if (data.permission && typeof data.permission === 'object')
-                return data.permission;
-        }
-        catch {
-            // Fall through to global config
-        }
-    }
-    // Fallback to global config for non-project folders
     const permissions = config.get('projectPermissions') || [];
-    return permissions.find((p) => p.path === projectPath) || null;
+    return permissions.find((p) => grantMatches(p, projectPath)) ?? null;
 }
 /**
- * Set project permission in local .codeep/config.json or global config
+ * Record a permission grant in the global config.
  */
 export function setProjectPermission(projectPath, read, write) {
     const permission = {
-        path: projectPath,
+        path: resolve(projectPath),
         readPermission: read,
         writePermission: write,
         grantedAt: new Date().toISOString(),
     };
-    // Try to save to local .codeep/config.json (for recognized projects)
-    const configPath = getLocalConfigPath(projectPath);
-    if (configPath) {
-        let data = {};
-        if (existsSync(configPath)) {
-            try {
-                data = JSON.parse(readFileSync(configPath, 'utf-8'));
-            }
-            catch {
-                // Invalid JSON, start fresh
-            }
-        }
-        data.permission = permission;
-        writeFileSync(configPath, JSON.stringify(data, null, 2));
-        return;
-    }
-    // Fallback to global config for non-project folders
-    const permissions = config.get('projectPermissions') || [];
-    const existingIndex = permissions.findIndex((p) => p.path === projectPath);
-    if (existingIndex >= 0) {
-        permissions[existingIndex] = permission;
-    }
-    else {
-        permissions.push(permission);
-    }
+    const permissions = (config.get('projectPermissions') || []).filter((p) => !grantMatches(p, projectPath));
+    permissions.push(permission);
     config.set('projectPermissions', permissions);
 }
 /**
- * Remove project permission from local .codeep/config.json or global config
+ * Remove a project's permission from the global config. A grant an older
+ * version wrote into the project for this same directory is removed too, so
+ * it does not linger in a file that may be committed.
  */
 export function removeProjectPermission(projectPath) {
-    // Try to remove from local .codeep/config.json
-    const configPath = getLocalConfigPath(projectPath);
-    if (configPath && existsSync(configPath)) {
+    let removed = false;
+    const permissions = config.get('projectPermissions') || [];
+    const kept = permissions.filter((p) => !grantMatches(p, projectPath));
+    if (kept.length !== permissions.length) {
+        config.set('projectPermissions', kept);
+        removed = true;
+    }
+    const configPath = localConfigFile(projectPath);
+    if (configPath && existsSync(configPath) && !leadsOutsideProject(configPath, projectPath)) {
         try {
             const data = JSON.parse(readFileSync(configPath, 'utf-8'));
-            if (data.permission) {
+            if (data && typeof data === 'object' && grantMatches(data.permission, projectPath)) {
                 delete data.permission;
-                writeFileSync(configPath, JSON.stringify(data, null, 2));
-                return true;
+                writeProjectFile(projectPath, configPath, JSON.stringify(data, null, 2));
             }
         }
         catch {
-            // Fall through to global config
+            // Unreadable, symlinked or unwritable: it no longer grants anything.
         }
     }
-    // Try to remove from global config
-    const permissions = config.get('projectPermissions') || [];
-    const existingIndex = permissions.findIndex((p) => p.path === projectPath);
-    if (existingIndex >= 0) {
-        permissions.splice(existingIndex, 1);
-        config.set('projectPermissions', permissions);
-        return true;
-    }
-    return false;
+    return removed;
 }
 export function hasReadPermission(projectPath) {
     const perm = getProjectPermission(projectPath);

package/dist/renderer/agentExecution.d.ts

@@ -23,17 +23,45 @@ export interface AppExecutionContext {
     setAbortController: (ctrl: AbortController | null) => void;
     formatAddedFilesContext: () => string;
     handleCommand: (command: string, args: string[]) => Promise<void>;
+    /** The conversation this run belongs to. Saved under this id; the global
+     *  currentSessionId is only a fallback and can name a different one. */
+    sessionId?: string;
+    /** The conversation on screen now. A run can outlive a switch to another
+     *  one (/new, /sessions, /rename), since tools do not stop on abort. */
+    getSessionId?: () => string;
     sessionDisplayName?: string;
     setSessionDisplayName?: (name: string | null) => void;
 }
 export declare function isDangerousTool(toolName: string, parameters: Record<string, unknown>): boolean;
 export declare function requestToolConfirmation(app: App, tool: string, parameters: Record<string, unknown>, onConfirm: () => void, onCancel: () => void): void;
+/**
+ * Model-written text shown in a permission dialog, with every character that
+ * could change how the rest of it looks spelled out: an ESC sequence would be
+ * read as a style (conceal, black on black) and a bidi override or zero-width
+ * character reorders or hides text, so the user could approve a command they
+ * were not shown. Newlines are left for the caller to lay out.
+ */
+export declare function showControls(text: string): string;
+/**
+ * The target of a tool call as dialog lines, each `width` terminal columns at
+ * most. Shown whole where it fits: an MCP call's arguments or a long command
+ * matter from the first character. Past `maxLines` the middle gives way, and a
+ * line says how much of it is not shown.
+ */
+export declare function wrapConfirmTarget(target: string, width: number, maxLines?: number): string[];
 export interface PendingInteractiveContext {
     originalTask: string;
     context: import('../utils/interactive').InteractiveContext;
     dryRun: boolean;
 }
-export declare function runAgentTask(task: string, dryRun: boolean, ctx: AppExecutionContext, getPendingInteractive: () => PendingInteractiveContext | null, setPendingInteractive: (v: PendingInteractiveContext | null) => void): Promise<void>;
-export declare function executeAgentTask(task: string, dryRun: boolean, ctx: AppExecutionContext): Promise<void>;
+/** How a run ended. 'not-started' covers a run that was refused, declined at
+ *  a confirmation, or held for clarifying questions. */
+export type AgentRunOutcome = 'success' | 'failed' | 'aborted' | 'interrupted' | 'not-started';
+export interface RunAgentTaskOptions {
+    /** Called once, when the run has ended or will not start. */
+    onFinished?: (outcome: AgentRunOutcome) => void;
+}
+export declare function runAgentTask(task: string, dryRun: boolean, ctx: AppExecutionContext, getPendingInteractive: () => PendingInteractiveContext | null, setPendingInteractive: (v: PendingInteractiveContext | null) => void, opts?: RunAgentTaskOptions): Promise<void>;
+export declare function executeAgentTask(task: string, dryRun: boolean, ctx: AppExecutionContext): Promise<AgentRunOutcome>;
 export declare function runSkill(nameOrShortcut: string, args: string[], ctx: AppExecutionContext): Promise<boolean>;
 export declare function runCommandChain(commands: string[], index: number, ctx: AppExecutionContext): void;