dsh-coding-sidebar 1.0.8 → 1.0.9

package/lib/index.js

@@ -1,5 +1,5 @@
 import { createRequire } from "node:module";
-import { mkdir, open, opendir, readFile, readdir, realpath, rename, rm, stat, writeFile } from "node:fs/promises";
+import { access, lstat, mkdir, open, opendir, readFile, readdir, realpath, rename, rm, stat, unlink, writeFile } from "node:fs/promises";
 import { basename, dirname, extname, isAbsolute, join, relative, resolve, sep, win32 } from "node:path";
 import { WebSocket, WebSocketServer } from "ws";
 import z from "schemastery";
@@ -377,7 +377,8 @@ async function ensureWorkspaceWritePath(cwd, target) {
 //#endregion
 //#region src/fs-operations.ts
 /**
-* Workspace-safe file mutations for the sidebar (the upload route today).
+* Workspace-safe file mutations for the sidebar: the upload route plus the
+* file tree's rename and delete.
 *
 * Every write is confined to the real session workspace: the upload
 * directory is resolved absolute and its target is checked through existing
@@ -387,6 +388,13 @@ async function ensureWorkspaceWritePath(cwd, target) {
 * to a uniquely named temp sibling
 * and are renamed into place, so a failed, aborted, or oversized upload never
 * leaves a partial file at the target path.
+*
+* The tree's rename/delete (below) are link-aware: existence and containment
+* are verified against the fully resolved target (a symlink pointing outside
+* the workspace is refused), but the operation itself addresses the lexical
+* row path — renaming or deleting a symlink row renames/unlinks the LINK,
+* never its target, matching what the tree row visually names (VS Code
+* semantics). Containment is always enforced (no fence toggle on this fork).
 */
 /**
 * Stream `chunks` into `dir/relativePath` atomically: a uniquely named temp
@@ -443,6 +451,86 @@ async function writeWorkspaceUpload(input) {
 		throw error;
 	}
 }
+/** Resolve a tree-row path against the session workspace (absolute rows pass through). */
+function resolveRowPath(cwd, target) {
+	return isAbsolute(target) ? target : join(cwd, target);
+}
+/** Resolve one existing entry for a link-aware mutation: the lexical row path
+* plus its fully resolved real target (containment-checked). Resolution
+* failures become fs-errors, mirroring path-security's semantics. */
+async function resolveEntry(cwd, target) {
+	const absolute = requireAbsolute(resolveRowPath(cwd, target));
+	let real;
+	let realCwd;
+	try {
+		[realCwd, real] = await Promise.all([realpath(cwd), realpath(absolute)]);
+	} catch (error) {
+		throw new SidebarError("fs-error", `cannot resolve "${target}": ${error instanceof Error ? error.message : String(error)}`, 400);
+	}
+	if (!isWithin(realCwd, real)) throw new SidebarError("forbidden", `path "${target}" is outside workspace`, 403);
+	return {
+		absolute,
+		real,
+		realCwd
+	};
+}
+/** Whether a path exists (ENOENT → false; other failures propagate). */
+async function pathExists(target) {
+	try {
+		await access(target);
+		return true;
+	} catch (error) {
+		if (error.code === "ENOENT") return false;
+		throw error;
+	}
+}
+/**
+* Rename one tree row within its directory: `path` → `<parent>/<name>`.
+* The new name must be a single path segment (this is rename, not move);
+* an existing destination is refused (POSIX rename would clobber it
+* silently); the workspace root itself is never renamable; a symlink row
+* renames the link, not its target. A no-op rename (same name) succeeds
+* without touching the filesystem.
+*
+* @throws SidebarError with a wire code for shape, containment, existence
+* and root failures.
+*/
+async function renameWorkspaceEntry(input) {
+	const { cwd, path, name } = input;
+	if (name === "" || name === "." || name === ".." || name.includes("/") || name.includes("\\")) throw new SidebarError("bad-request", "name must be a single path segment", 400);
+	const { absolute, real, realCwd } = await resolveEntry(cwd, path);
+	if (real === realCwd) throw new SidebarError("fs-error", "cannot rename the workspace root", 400);
+	if (basename(absolute) === name) return { path: absolute };
+	const safeDestination = await ensureWorkspaceWritePath(cwd, join(dirname(absolute), name));
+	if (await pathExists(safeDestination)) throw new SidebarError("fs-error", `"${name}" already exists`, 409);
+	try {
+		await rename(absolute, safeDestination);
+	} catch (error) {
+		throw new SidebarError("fs-error", `cannot rename "${path}" to "${name}": ${error instanceof Error ? error.message : String(error)}`, 400);
+	}
+	return { path: safeDestination };
+}
+/**
+* Delete one tree row permanently (there is no trash on the host): files are
+* unlinked, directories removed recursively, a symlink row unlinks the LINK
+* only (lstat decides, so a link to a directory does not recurse into its
+* target). The workspace root itself is never removable.
+*
+* @throws SidebarError with a wire code for containment, existence and
+* root failures.
+*/
+async function removeWorkspaceEntry(input) {
+	const { cwd, path } = input;
+	const { absolute, real, realCwd } = await resolveEntry(cwd, path);
+	if (real === realCwd) throw new SidebarError("fs-error", "cannot remove the workspace root", 400);
+	try {
+		if ((await lstat(absolute)).isDirectory()) await rm(absolute, { recursive: true });
+		else await unlink(absolute);
+	} catch (error) {
+		throw new SidebarError("fs-error", `cannot remove "${path}": ${error instanceof Error ? error.message : String(error)}`, 400);
+	}
+	return { path: absolute };
+}
 //#endregion
 //#region src/fs-search.ts
 /**
@@ -1201,6 +1289,36 @@ async function show(cwd, rev, path, selected) {
 		return null;
 	}
 }
+/**
+* Both sides' full file contents for a diff-fold expansion. `path` is
+* repo-relative. The sides resolve per diff kind: a commit reads
+* `<hash>^` vs `<hash>`; a staged change reads HEAD vs the index (`:`);
+* an unstaged change reads HEAD vs the working tree file on disk (a side
+* that does not exist — untracked, deleted, binary-refused — comes back
+* null and the client degrades the fold to a static marker).
+*/
+async function foldContents(cwd, path, opts = {}, selected) {
+	const root = await repoRoot(cwd, selected);
+	if (opts.hash !== void 0) {
+		const [old, neu] = await Promise.all([show(root, `${opts.hash}^`, path, selected), show(root, opts.hash, path, selected)]);
+		return {
+			old,
+			new: neu
+		};
+	}
+	if (opts.staged === true) {
+		const [old, neu] = await Promise.all([show(root, "HEAD", path, selected), show(root, ":", path, selected)]);
+		return {
+			old,
+			new: neu
+		};
+	}
+	const [old, neu] = await Promise.all([show(root, "HEAD", path, selected), readFile(isAbsolute(path) ? path : join(root, path), "utf8").catch(() => null)]);
+	return {
+		old,
+		new: neu
+	};
+}
 /** Full patch text of one commit (`git show` with the commit header suppressed).
 *  Merge commits show their diff against the first parent (`-m --first-parent`
 *  is a no-op for regular commits), so a history click always has content. */
@@ -4133,6 +4251,21 @@ function buildApi(ctx, ptyManager, agentPtyRegistry, resolved, terminalShell, ge
 			}
 			return { ok: true };
 		},
+		"fs.rename": async (payload) => {
+			const { cwd } = await cwdOf(payload);
+			return renameWorkspaceEntry({
+				cwd,
+				path: requireString(payload, "path"),
+				name: requireString(payload, "name")
+			});
+		},
+		"fs.remove": async (payload) => {
+			const { cwd } = await cwdOf(payload);
+			return removeWorkspaceEntry({
+				cwd,
+				path: requireString(payload, "path")
+			});
+		},
 		"git.worktrees": async (payload) => {
 			const { cwd } = await gitCwdOf(payload);
 			const selected = selectedRepoOf(payload);
@@ -4203,6 +4336,15 @@ function buildApi(ctx, ptyManager, agentPtyRegistry, resolved, terminalShell, ge
 			const path = await resolveGitPath(cwd, requireString(payload, "path"), repoRoot);
 			return { content: await show(cwd, requireString(payload, "rev"), path, repoRoot) };
 		},
+		"git.fold-contents": async (payload) => {
+			const { cwd } = await gitCwdOf(payload);
+			const repoRoot = selectedRepoOf(payload);
+			const record = payload;
+			return await foldContents(cwd, await resolveGitPath(cwd, requireString(record, "path"), repoRoot), {
+				staged: record.staged === true,
+				hash: typeof record.hash === "string" ? record.hash : void 0
+			}, repoRoot);
+		},
 		"pty.close": (payload) => {
 			const sessionId = requireString(payload, "sessionId");
 			const tab = requireString(payload, "tab");
@@ -4214,6 +4356,13 @@ function buildApi(ctx, ptyManager, agentPtyRegistry, resolved, terminalShell, ge
 			agentPtyRegistry?.close(uuid);
 			return { ok: true };
 		},
+		"agent-pty.skip-wait": (payload) => {
+			const uuid = requireString(payload, "uuid");
+			return {
+				ok: true,
+				skipped: agentPtyRegistry?.skipWait(uuid) ?? 0
+			};
+		},
 		"terminal.deps": () => depsStatus(),
 		"jobs.output": (payload) => jobsApi.output(payload),
 		"jobs.kill": (payload) => jobsApi.kill(payload),

package/lib/types/client/DiffView.d.ts

@@ -1,3 +1,5 @@
+import { type SessionScope } from './api.ts';
+import type { SidebarDiffRef } from './state.ts';
 /** One rendered diff line. */
 export interface DiffLine {
     kind: 'ctx' | 'del' | 'add' | 'meta';
@@ -41,11 +43,41 @@ export interface ParsedDiff {
  * can still draw its path.
  */
 export declare function parseUnifiedDiff(text: string): ParsedDiff;
+/** The old/new line range one hidden gap spans (both sides derive from the
+ *  surrounding hunk headers and their counted rows). */
+interface DiffFoldRange {
+    oldStart: number;
+    oldEnd: number;
+    newStart: number;
+    newEnd: number;
+}
+/**
+ * Materialize a git gap fold's hidden rows from the two sides' full file
+ * contents, by the fold's known line ranges: the old side drives context
+ * rows (each mapped onto the new side through the fold's offset — a gap is
+ * an unchanged run, so the sides align), and new-side lines the old range
+ * never reaches become pure additions. Line numbers clip to the actual
+ * content (a no-newline file's ranges can overrun by one); `\r` endings
+ * survive verbatim, like git's own context lines.
+ */
+export declare function foldRowsFromContents(fold: DiffFoldRange, oldContent: string, newContent: string): DiffLine[];
 export interface DiffViewProps {
     /** Unified diff text (`git.diff` or `git.commit-diff` payloads). */
     diff: string;
     /** Untracked-file content: when present, renders as a full-file addition instead of parsing. */
     untrackedPath?: string;
     untrackedContent?: string;
+    /**
+     * When present (a worktree/commit diff ref plus its scope), hunk gaps
+     * render an expandable fold: clicking resolves both sides' full contents
+     * (`git.fold-contents`) and materializes the hidden context rows. Absent
+     * (or an untracked full-addition render) — no fold rows at all.
+     */
+    foldSource?: {
+        scope: SessionScope;
+        ref: SidebarDiffRef;
+        cwd: string | undefined;
+    };
 }
-export declare function DiffView({ diff, untrackedPath, untrackedContent }: DiffViewProps): import("react").JSX.Element | null;
+export declare function DiffView({ diff, untrackedPath, untrackedContent, foldSource }: DiffViewProps): import("react").JSX.Element | null;
+export {};

package/lib/types/client/EditorHost.d.ts

@@ -10,4 +10,7 @@ export declare function EditorHost(props: {
     revealed: string[];
     onToggleDir: (path: string) => void;
     onReferenceFile: (path: string, isDir: boolean) => void;
+    /** Tree-row mutations (passed through to the file tree; absent → hidden). */
+    onPathRenamed?: (oldPath: string, newPath: string) => void;
+    onPathRemoved?: (path: string) => void;
 }): import("react").JSX.Element;

package/lib/types/client/FileTree.d.ts

@@ -35,4 +35,8 @@ export declare function FileTree(props: {
     onUploadRequest: (dir: string, items: UploadItem[]) => void;
     /** True while an upload is in flight (drops are ignored). */
     busy: boolean;
+    /** A tree row was renamed (retarget open tabs; absent → no rename entry). */
+    onPathRenamed?: (oldPath: string, newPath: string) => void;
+    /** A tree row was removed (close affected tabs; absent → no delete entry). */
+    onPathRemoved?: (path: string) => void;
 }): import("react").JSX.Element;

package/lib/types/client/TerminalWaitBanner.d.ts

@@ -0,0 +1,6 @@
+/** Truncate one needle for inline display (title attr carries the full text). */
+export declare function truncateNeedle(needle: string): string;
+export declare function TerminalWaitBanner(props: {
+    needle: string;
+    onSkip: () => void;
+}): import("react").JSX.Element;

package/lib/types/client/TreePanel.d.ts

@@ -18,6 +18,9 @@ export declare function TreePanel(props: {
     onOpenWith?: (targetId: string, path: string) => void;
     onToggleOpenWithPin?: (targetId: string) => void;
     onReferenceFile: (path: string, isDir: boolean) => void;
+    /** Tree-row mutations (passed through to the file tree; absent → hidden). */
+    onPathRenamed?: (oldPath: string, newPath: string) => void;
+    onPathRemoved?: (path: string) => void;
     /** Full-window presentation: the panel fills its host instead of docking
      *  at a fixed width. */
     full?: boolean;

package/lib/types/client/api.d.ts

@@ -138,6 +138,16 @@ export declare const api: {
     fsWrite: (scope: SessionScope, path: string, content: string) => Promise<{
         ok: true;
     }>;
+    /** Rename one tree row within its directory (single-segment name; a
+     *  destination-existence clash is a 409; symlink rows rename the link). */
+    fsRename: (scope: SessionScope, path: string, name: string) => Promise<{
+        path: string;
+    }>;
+    /** Delete one tree row permanently (recursive for directories; a symlink
+     *  row unlinks the link only). */
+    fsRemove: (scope: SessionScope, path: string) => Promise<{
+        path: string;
+    }>;
     /** Upload one file's raw bytes into `dir` (keeps the folder tree via
      *  `relativePath`); the host streams it under the session workspace. */
     uploadFile: (scope: SessionScope, dir: string, relativePath: string, body: Blob, signal?: AbortSignal) => Promise<{
@@ -171,6 +181,16 @@ export declare const api: {
     gitCommitDiff: (scope: SessionScope, hash: string, worktree?: string, signal?: AbortSignal) => Promise<{
         diff: string;
     }>;
+    /** Both sides' full file contents for a diff-fold expansion; a missing
+     *  side is null (untracked / deleted) and the view degrades the fold. */
+    gitFoldContents: (scope: SessionScope, opts: {
+        path: string;
+        staged?: boolean;
+        hash?: string;
+    }, worktree?: string, signal?: AbortSignal) => Promise<{
+        old: string | null;
+        new: string | null;
+    }>;
     /** Discard the worktree changes of one file (the index is untouched). */
     gitDiscard: (scope: SessionScope, path: string, worktree?: string) => Promise<{
         ok: true;
@@ -193,6 +213,12 @@ export declare const api: {
     agentPtyClose: (uuid: string) => Promise<{
         ok: true;
     }>;
+    /** Skip every active terminal_wait_for on one agent terminal (the wait
+     *  banner's skip button). Idempotent: {skipped:0} when none is active. */
+    agentSkipWait: (uuid: string) => Promise<{
+        ok: true;
+        skipped: number;
+    }>;
     /** Terminal dependency status (issue #140): after a WS close 1011 with
      *  reason `pty-deps-missing` the view fetches the full repair details here
      *  (the close reason itself is capped at 123 bytes). */

package/lib/types/client/locales.d.ts

@@ -159,6 +159,18 @@ export declare const zh: {
     producedOpen: string;
     showInFolder: string;
     disconnected: string;
+    terminalWaitBanner: string;
+    terminalSkipWait: string;
+    gitFoldExpand: string;
+    gitFoldLoading: string;
+    gitFoldFailed: string;
+    rename: string;
+    renameInvalid: string;
+    delete: string;
+    deleteTitle: string;
+    deleteDescFile: string;
+    deleteDescDir: string;
+    dismiss: string;
     exited: string;
     noSession: string;
     pluginNotLoaded: string;

package/lib/types/client/state.d.ts

@@ -110,6 +110,17 @@ export interface SidebarState {
     splits: SplitNode;
     /** Free windows (tabs dragged out onto the conversation area). */
     floats: FloatWindow[];
+    /**
+     * Live agent-terminal wait state (uuid → the wait the model currently
+     * blocks on in `terminal_wait_for`), mirrored from the host's
+     * agent-terminals push. Transient by design: sanitizeState never restores
+     * it, so a reload starts clean and the next push (sent immediately on WS
+     * attach) repopulates it.
+     */
+    agentWaits: Record<string, {
+        needle: string;
+        since: number;
+    }>;
 }
 export declare const PANEL_MIN = 280;
 export declare const PANEL_MAX = 640;
@@ -325,6 +336,10 @@ export declare function agentTabId(uuid: string): string;
 export declare function reconcileAgentTerminals(state: SidebarState, agentTerminals: ReadonlyArray<{
     uuid: string;
     title: string;
+    waiting?: {
+        needle: string;
+        since: number;
+    } | null;
 }>): SidebarState;
 /** Immutable snapshot handed to React (replaced only on real changes). */
 export interface SidebarSnapshot {

package/lib/types/fs-operations.d.ts

@@ -26,3 +26,45 @@ export declare function writeWorkspaceUpload(input: WorkspaceUploadInput): Promi
     path: string;
     size: number;
 }>;
+/** Inputs of one tree-row rename. */
+export interface WorkspaceRenameInput {
+    /** The session workspace root; the renamed entry must stay inside it. */
+    cwd: string;
+    /** Absolute path of the row as the tree displays it (may be a symlink). */
+    path: string;
+    /** The new base name (single segment — rename never moves across directories). */
+    name: string;
+}
+/**
+ * Rename one tree row within its directory: `path` → `<parent>/<name>`.
+ * The new name must be a single path segment (this is rename, not move);
+ * an existing destination is refused (POSIX rename would clobber it
+ * silently); the workspace root itself is never renamable; a symlink row
+ * renames the link, not its target. A no-op rename (same name) succeeds
+ * without touching the filesystem.
+ *
+ * @throws SidebarError with a wire code for shape, containment, existence
+ * and root failures.
+ */
+export declare function renameWorkspaceEntry(input: WorkspaceRenameInput): Promise<{
+    path: string;
+}>;
+/** Inputs of one tree-row delete. */
+export interface WorkspaceRemoveInput {
+    /** The session workspace root; the removed entry must stay inside it. */
+    cwd: string;
+    /** Absolute path of the row as the tree displays it (may be a symlink). */
+    path: string;
+}
+/**
+ * Delete one tree row permanently (there is no trash on the host): files are
+ * unlinked, directories removed recursively, a symlink row unlinks the LINK
+ * only (lstat decides, so a link to a directory does not recurse into its
+ * target). The workspace root itself is never removable.
+ *
+ * @throws SidebarError with a wire code for containment, existence and
+ * root failures.
+ */
+export declare function removeWorkspaceEntry(input: WorkspaceRemoveInput): Promise<{
+    path: string;
+}>;

package/lib/types/git.d.ts

@@ -112,6 +112,21 @@ export declare function log(cwd: string, count?: number, skip?: number, selected
  * revision has no such path (a new/untracked file has no HEAD side).
  */
 export declare function show(cwd: string, rev: string, path: string, selected?: string): Promise<string | null>;
+/**
+ * Both sides' full file contents for a diff-fold expansion. `path` is
+ * repo-relative. The sides resolve per diff kind: a commit reads
+ * `<hash>^` vs `<hash>`; a staged change reads HEAD vs the index (`:`);
+ * an unstaged change reads HEAD vs the working tree file on disk (a side
+ * that does not exist — untracked, deleted, binary-refused — comes back
+ * null and the client degrades the fold to a static marker).
+ */
+export declare function foldContents(cwd: string, path: string, opts?: {
+    staged?: boolean;
+    hash?: string;
+}, selected?: string): Promise<{
+    old: string | null;
+    new: string | null;
+}>;
 /** Full patch text of one commit (`git show` with the commit header suppressed).
  *  Merge commits show their diff against the first parent (`-m --first-parent`
  *  is a no-op for regular commits), so a history click always has content. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-coding-sidebar",
-  "version": "1.0.8",
+  "version": "1.0.9",
   "description": "DSH web plugin: a VSCode-like right sidebar (explorer / editor / terminal / git / browser), isolated per conversation session. Exposes the betterSidebar service for other plugins to register sidebar tabs and file viewers. KCoder-maintained fork of DSH-better-sidebar 0.17.2 (bottom panel removed, upstream-decoupled release line).",
   "type": "module",
   "repository": {

package/src/client/DiffTab.tsx

@@ -103,7 +103,16 @@ export function DiffTab(props: { sessionId: string; cwd: string | undefined; dif
         <>
           {data.untracked !== undefined
             ? <DiffView diff="" untrackedPath={diff.kind === 'worktree' ? diff.path : ''} untrackedContent={data.untracked} />
-            : <DiffView diff={data.diff} />}
+            : (
+              <DiffView
+                diff={data.diff}
+                foldSource={{
+                  scope: { sessionId, cwd, ...(diff.repoRoot !== undefined ? { repoRoot: diff.repoRoot } : {}) },
+                  ref: diff,
+                  cwd,
+                }}
+              />
+            )}
           {data.diff === '' && data.untracked === undefined && (
             <div className={css.gitEmpty}>{t('diffEmpty')}</div>
           )}