@cjhyy/code-shell-server 0.9.23 → 0.9.26

package/dist/panels/resources/clone.d.ts

@@ -0,0 +1,13 @@
+/** Host-only optimization. Both paths are managed storage, never guest paths. */
+export declare function stageResourceClone(options: {
+    sourcePath: string;
+    stagingDirectory: string;
+    targetDevice: number;
+    verify(): Promise<void>;
+    signal?: AbortSignal;
+}): Promise<{
+    path: string;
+    handle: import("fs/promises").FileHandle;
+    verify: () => Promise<void>;
+    close: () => Promise<void>;
+} | undefined>;

package/dist/panels/resources/clone.js

@@ -0,0 +1,99 @@
+import { spawn } from "node:child_process";
+import { constants } from "node:fs";
+import { copyFile, lstat, mkdtemp, open, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { sameResourceIdentity } from "./directories.js";
+import { mediaSourceIdentity } from "./library.js";
+/** Host-only optimization. Both paths are managed storage, never guest paths. */
+export async function stageResourceClone(options) {
+    const { sourcePath, stagingDirectory, signal } = options;
+    signal?.throwIfAborted();
+    await options.verify();
+    signal?.throwIfAborted();
+    const source = await lstat(sourcePath);
+    if (!source.isFile() || source.isSymbolicLink())
+        throw new Error("Invalid resource clone source");
+    if (source.dev !== options.targetDevice || !["darwin", "linux"].includes(process.platform))
+        return undefined;
+    const staging = await lstat(stagingDirectory);
+    if (!staging.isDirectory() || staging.isSymbolicLink())
+        throw new Error("Invalid resource clone staging directory");
+    if (staging.dev !== source.dev)
+        return undefined;
+    const directory = await mkdtemp(join(stagingDirectory, "clone-"));
+    const identity = await lstat(directory);
+    const path = join(directory, "content");
+    let handle;
+    const verify = async () => {
+        signal?.throwIfAborted();
+        await options.verify();
+        const currentStaging = await lstat(stagingDirectory);
+        const currentDirectory = await lstat(directory);
+        const currentSource = await lstat(sourcePath);
+        if (!currentStaging.isDirectory() ||
+            currentStaging.isSymbolicLink() ||
+            !sameResourceIdentity(currentStaging, staging) ||
+            !currentDirectory.isDirectory() ||
+            currentDirectory.isSymbolicLink() ||
+            !sameResourceIdentity(currentDirectory, identity) ||
+            !currentSource.isFile() ||
+            currentSource.isSymbolicLink() ||
+            Object.entries(mediaSourceIdentity(source)).some(([key, value]) => currentSource[key] !== value))
+            throw new Error("Resource changed during clone");
+        signal?.throwIfAborted();
+    };
+    const close = async () => {
+        await handle?.close().catch(() => { });
+        handle = undefined;
+        const current = await lstat(directory).catch(() => undefined);
+        if (current?.isDirectory() && sameResourceIdentity(current, identity))
+            await rm(directory, { recursive: true, force: true }).catch(() => { });
+    };
+    try {
+        await verify();
+        try {
+            if (process.platform === "darwin") {
+                // Electron's Node/libuv does not implement FICLONE on macOS. The OS
+                // utility uses clonefile, with ordinary copy fallback on other volumes.
+                // Its target is fresh Host-private storage, outside the tool grant.
+                await new Promise((resolve, reject) => {
+                    const child = spawn("/bin/cp", ["-c", "-n", sourcePath, path], {
+                        stdio: "ignore",
+                        signal,
+                    });
+                    child.once("error", reject);
+                    child.once("close", (code) => {
+                        if (code === 0)
+                            resolve();
+                        else
+                            reject(new Error("Native resource clone failed"));
+                    });
+                });
+            }
+            else {
+                // FORCE prevents a failed Linux reflink from silently doing another
+                // full copy before the existing streaming fallback is used.
+                await copyFile(sourcePath, path, constants.COPYFILE_EXCL | constants.COPYFILE_FICLONE_FORCE);
+            }
+        }
+        catch (error) {
+            await verify();
+            if (process.platform !== "darwin" &&
+                !["ENOSYS", "ENOTSUP", "EOPNOTSUPP", "EXDEV", "EINVAL"].includes(error.code ?? ""))
+                throw error;
+            await close();
+            return undefined;
+        }
+        await verify();
+        handle = await open(path, constants.O_RDWR | (constants.O_NOFOLLOW ?? 0) | (constants.O_NONBLOCK ?? 0));
+        const cloned = await handle.stat();
+        if (!cloned.isFile() || cloned.size !== source.size || sameResourceIdentity(cloned, source))
+            throw new Error("Invalid cloned resource");
+        await handle.chmod(0o600);
+        return { path, handle, verify, close };
+    }
+    catch (error) {
+        await close();
+        throw error;
+    }
+}

package/dist/panels/resources/service.js

@@ -2,7 +2,8 @@ import { createHash, randomUUID } from "node:crypto";
 import { constants } from "node:fs";
 import { link, lstat, open, rm } from "node:fs/promises";
 import { ResourceLibrary, mediaSourceIdentity } from "./library.js";
-import { mediaScopeKey, normalizeMediaScope } from "./storage.js";
+import { mediaDirectory, mediaScopeKey, normalizeMediaScope } from "./storage.js";
+import { stageResourceClone } from "./clone.js";
 import { openResourceDirectory, resourceRelativePath, sameResourceIdentity, } from "./directories.js";
 import { ResourceUploadIngest } from "./uploads.js";
 import { ExternalResourceReferences } from "./references.js";
@@ -138,43 +139,71 @@ export class PanelResourceService {
             await directory.close();
         }
     }
-    async materialize(scope, raw, context) {
+    async materialize(scope, raw, context, cloneManaged = true) {
         const input = object(raw, ["assetId", "directoryHandle", "path"]);
         const asset = await this.get(scope, assetId(input.assetId));
         const directory = await this.directory(scope, input, context, true);
-        const temporary = directory.location(`.${randomUUID()}.resource-partial`);
+        let temporary = directory.location(`.${randomUUID()}.resource-partial`);
+        let clone;
         let destination;
         let published = false;
         let identity;
         try {
             await directory.verify();
-            destination = await open(temporary, constants.O_RDWR | constants.O_CREAT | constants.O_EXCL | (constants.O_NOFOLLOW ?? 0), 0o600);
+            if (cloneManaged && "sha256" in asset) {
+                const sourcePath = await this.library.resolvePath(scope, asset.id);
+                const stagingDirectory = await mediaDirectory(this.options.rootDirectory, [
+                    "scopes",
+                    mediaScopeKey(scope),
+                    "materialize",
+                ]);
+                clone = await stageResourceClone({
+                    sourcePath,
+                    stagingDirectory,
+                    targetDevice: directory.identities.at(-1).dev,
+                    verify: directory.verify,
+                    signal: context.signal,
+                });
+            }
+            if (clone) {
+                temporary = clone.path;
+                destination = clone.handle;
+            }
+            else {
+                destination = await open(temporary, constants.O_RDWR | constants.O_CREAT | constants.O_EXCL | (constants.O_NOFOLLOW ?? 0), 0o600);
+            }
             identity = await destination.stat();
-            const source = await this.openRead(scope, asset.id, { signal: context.signal });
-            const hash = createHash("sha256");
-            let bytes = 0;
-            try {
-                for await (const chunk of source.body) {
-                    await directory.verify();
-                    if (bytes + chunk.length > asset.bytes)
-                        throw new Error("Resource content changed");
-                    hash.update(chunk);
-                    let offset = 0;
-                    while (offset < chunk.length) {
-                        const written = await destination.write(chunk, offset, chunk.length - offset, bytes + offset);
-                        if (!written.bytesWritten)
-                            throw new Error("Resource copy stopped making progress");
-                        offset += written.bytesWritten;
+            let sha256;
+            if (clone && "sha256" in asset) {
+                sha256 = asset.sha256;
+            }
+            else {
+                const source = await this.openRead(scope, asset.id, { signal: context.signal });
+                const hash = createHash("sha256");
+                let bytes = 0;
+                try {
+                    for await (const chunk of source.body) {
+                        await directory.verify();
+                        if (bytes + chunk.length > asset.bytes)
+                            throw new Error("Resource content changed");
+                        hash.update(chunk);
+                        let offset = 0;
+                        while (offset < chunk.length) {
+                            const written = await destination.write(chunk, offset, chunk.length - offset, bytes + offset);
+                            if (!written.bytesWritten)
+                                throw new Error("Resource copy stopped making progress");
+                            offset += written.bytesWritten;
+                        }
+                        bytes += chunk.length;
                     }
-                    bytes += chunk.length;
                 }
+                finally {
+                    source.body?.destroy();
+                }
+                sha256 = hash.digest("hex");
+                if (bytes !== asset.bytes || ("sha256" in asset && sha256 !== asset.sha256))
+                    throw new Error("Resource content failed integrity validation");
             }
-            finally {
-                source.body?.destroy();
-            }
-            const sha256 = hash.digest("hex");
-            if (bytes !== asset.bytes || ("sha256" in asset && sha256 !== asset.sha256))
-                throw new Error("Resource content failed integrity validation");
             await destination.sync();
             // A tool may share the granted directory. Verify the actual destination,
             // not only the source stream, before publishing the materialized file.
@@ -195,6 +224,7 @@ export class PanelResourceService {
                 verified.ctimeMs !== completed.ctimeMs ||
                 copiedHash.digest("hex") !== sha256)
                 throw new Error("Materialized resource failed integrity verification");
+            await clone?.verify();
             await destination.close();
             destination = undefined;
             await directory.verify();
@@ -213,15 +243,21 @@ export class PanelResourceService {
                 if (current && sameResourceIdentity(current, identity))
                     await rm(directory.path, { force: true }).catch(() => { });
             }
-            throw error;
+            // Different bind mounts can share st_dev yet refuse hard links. Retry
+            // with a temporary file inside the target grant, after releasing this
+            // private clone and all held descriptors in finally.
+            if (!(clone && !published && error.code === "EXDEV"))
+                throw error;
         }
         finally {
             await destination?.close().catch(() => { });
             const current = await lstat(temporary).catch(() => undefined);
             if (current && identity && sameResourceIdentity(current, identity))
                 await rm(temporary, { force: true }).catch(() => { });
+            await clone?.close();
             await directory.close();
         }
+        return this.materialize(scope, raw, context, false);
     }
     async capture(scope, raw, context) {
         const input = object(raw, [

package/dist/sessions-service.d.ts

@@ -39,9 +39,11 @@ export interface DiskSessionMeta {
     cwd: string;
     title: string;
     updatedAt: number;
-    /** Sub-agents are returned only by an explicit parentSessionId query. */
+    /** Durable creation time, when supplied by the engine's state schema. */
+    createdAt?: number;
+    /** Sub-agents require an explicit parent query or the host's includeSubagents scan. */
     origin: "desktop" | "automation" | "subagent";
-    /** Present only when listing the direct children of a session. */
+    /** Present for direct-child queries and the host's complete task scan. */
     parentSessionId?: string;
     /** Normalized durable status for Pet/display consumers. */
     status?: "active" | "paused" | "completed" | "failed" | "cancelled";
@@ -68,6 +70,8 @@ export declare function listDiskSessions(opts: {
     limit: number;
     cursor?: string;
     includeArchived?: boolean;
+    /** Host read models may include children; ordinary sidebar queries stay top-level. */
+    includeSubagents?: boolean;
     parentSessionId?: string;
 }, baseDir?: string): Promise<ListDiskSessionsResult>;
 /**

package/dist/sessions-service.js

@@ -279,7 +279,7 @@ export async function listDiskSessions(opts, baseDir = sessionsRoot()) {
             if (state.parentSessionId !== parentSessionId)
                 continue;
         }
-        else if (state.parentSessionId) {
+        else if (state.parentSessionId && !opts.includeSubagents) {
             continue;
         }
         // Only desktop + automation belong in the desktop sidebar. Targeted
@@ -288,7 +288,7 @@ export async function listDiskSessions(opts, baseDir = sessionsRoot()) {
         const origin = state.origin;
         if (origin !== "desktop" &&
             origin !== "automation" &&
-            !(parentSessionId !== undefined && origin === "subagent")) {
+            !((parentSessionId !== undefined || opts.includeSubagents) && origin === "subagent")) {
             continue;
         }
         // Skip sessions whose project root has been deleted. Listing them led the
@@ -300,7 +300,21 @@ export async function listDiskSessions(opts, baseDir = sessionsRoot()) {
         const cwdStr = typeof state.cwd === "string" ? state.cwd : "";
         // A child transcript remains useful after its temporary worktree is gone;
         // targeted reads do not rebuild projects in the sidebar.
-        if (parentSessionId === undefined && cwdStr && !(await pathExists(cwdStr)))
+        const childParentId = typeof state.parentSessionId === "string" && state.parentSessionId
+            ? state.parentSessionId
+            : undefined;
+        if (childParentId &&
+            (!SAFE_ID.test(childParentId) ||
+                childParentId.length > 128 ||
+                childParentId.includes("..") ||
+                childParentId === "."))
+            continue;
+        if (state.parentSessionId && !childParentId)
+            continue;
+        if (parentSessionId === undefined &&
+            !(opts.includeSubagents && childParentId) &&
+            cwdStr &&
+            !(await pathExists(cwdStr)))
             continue;
         // Archived sessions are hidden from the default catalog. Filtering happens
         // before the push (like every other skip above), so the mtime cursor —
@@ -328,8 +342,13 @@ export async function listDiskSessions(opts, baseDir = sessionsRoot()) {
             title: (typeof state.title === "string" && state.title ? state.title : undefined) ??
                 (typeof state.summary === "string" && state.summary ? state.summary : id),
             updatedAt: mtime,
+            ...(typeof state.startedAt === "number" &&
+                Number.isFinite(state.startedAt) &&
+                state.startedAt >= 0
+                ? { createdAt: state.startedAt }
+                : {}),
             origin,
-            ...(parentSessionId !== undefined ? { parentSessionId } : {}),
+            ...(childParentId ? { parentSessionId: childParentId } : {}),
             status: state.status === "active" || state.status === "paused" || state.status === "completed"
                 ? state.status
                 : state.status === "aborted_streaming" || state.status === "aborted_tools"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cjhyy/code-shell-server",
-  "version": "0.9.23",
+  "version": "0.9.26",
   "description": "CodeShell server transport layer — mobile remote HTTP/WS host, pairing, passcode gate, tunnel, rooms, uploads, and session/attachment services. Electron-free; precursor of the auth gateway.",
   "type": "module",
   "main": "./dist/index.js",
@@ -60,13 +60,13 @@
     "clean": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\""
   },
   "dependencies": {
-    "@cjhyy/code-shell-capability-coding": "0.9.23",
-    "@cjhyy/code-shell-core": "0.9.23",
-    "@cjhyy/code-shell-web": "0.9.23",
+    "@cjhyy/code-shell-capability-coding": "0.9.26",
+    "@cjhyy/code-shell-core": "0.9.26",
+    "@cjhyy/code-shell-web": "0.9.26",
     "@modelcontextprotocol/sdk": "^1.12.1",
     "@types/ws": "^8.18.1",
     "ws": "^8.21.0",
-    "@cjhyy/code-shell-link": "0.9.23"
+    "@cjhyy/code-shell-link": "0.9.26"
   },
   "engines": {
     "node": ">=20.10"