export function parseSandboxStatSize(value: string | undefined): number {

const raw = value ?? "0";

if (!/^\d+$/.test(raw)) {

return 0;

}

const size = Number(raw);

return Number.isFinite(size) ? size : 0;

}

export function parseSandboxStatMtimeMs(value: string | undefined): number {

const raw = value ?? "0";

if (/^\d+(?:\.\d+)?$/.test(raw)) {

const mtimeMs = Number(raw) * 1000;

return Number.isFinite(mtimeMs) ? mtimeMs : 0;

}

const parsed = Date.parse(raw);

return Number.isFinite(parsed) ? parsed : 0;

}

expect(args).not.toContain("/workspace/nested/file.txt");

});

});

it("does not accept partial stat size output", async () => {

await withTempDir("openclaw-fs-bridge-stat-parse-", async (stateDir) => {

const workspaceDir = path.join(stateDir, "workspace");

await fs.mkdir(workspaceDir, { recursive: true });

mockedExecDockerRaw.mockImplementation(async (args) => {

const script = getDockerScript(args);

if (script.includes('readlink -f -- "$cursor"')) {

return dockerExecResult(`${getDockerArg(args, 1)}\n`);

}

if (script.includes('stat -c "%F|%s|%y"')) {

return dockerExecResult("regular file|12oops|not-a-date\n");

}

return dockerExecResult("");

});

const bridge = createSandboxFsBridge({

sandbox: createSandbox({

workspaceDir,

agentWorkspaceDir: workspaceDir,

}),

});

await expect(bridge.stat({ filePath: "note.txt" })).resolves.toMatchObject({

type: "file",

size: 0,

mtimeMs: 0,

});

});

});

});

} from "./fs-bridge-mutation-helper.js";

import { SandboxFsPathGuard } from "./fs-bridge-path-safety.js";

import { buildStatPlan, type SandboxFsCommandPlan } from "./fs-bridge-shell-command-plans.js";

import { parseSandboxStatMtimeMs, parseSandboxStatSize } from "./fs-bridge-stat-parse.js";

import type { SandboxFsBridge, SandboxFsStat, SandboxResolvedPath } from "./fs-bridge.types.js";

import {

buildSandboxFsMounts,

return new SandboxFsBridgeImpl(params.sandbox);

}

function parseStatMtimeMs(value: string | undefined): number {

const raw = value ?? "0";

if (/^\d+(?:\.\d+)?$/.test(raw)) {

return Number(raw) * 1000;

}

const parsed = Date.parse(raw);

return Number.isFinite(parsed) ? parsed : 0;

}

class SandboxFsBridgeImpl implements SandboxFsBridge {

private readonly sandbox: SandboxFsBridgeContext;

private readonly mounts: ReturnType<typeof buildSandboxFsMounts>;

}

const text = result.stdout.toString("utf8").trim();

const [typeRaw, sizeRaw, mtimeRaw] = text.split("|");

const size = Number.parseInt(sizeRaw ?? "0", 10);

return {

type: coerceStatType(typeRaw),

size: Number.isFinite(size) ? size : 0,

mtimeMs: parseStatMtimeMs(mtimeRaw),

size: parseSandboxStatSize(sizeRaw),

mtimeMs: parseSandboxStatMtimeMs(mtimeRaw),

};

}

});

},

);

it("does not return NaN or partial values for malformed stat output", async () => {

await withTempDir("openclaw-remote-fs-bridge-stat-", async (stateDir) => {

const workspaceDir = path.join(stateDir, "workspace");

await fs.mkdir(workspaceDir, { recursive: true });

const runtime: RemoteShellSandboxHandle = {

remoteWorkspaceDir: workspaceDir,

remoteAgentWorkspaceDir: workspaceDir,

runRemoteShellScript: async (command) => {

if (command.script.includes('if [ -e "$1" ] || [ -L "$1" ]')) {

return { stdout: Buffer.from("1\n"), stderr: Buffer.alloc(0), code: 0 };

}

if (command.script.includes('readlink -f -- "$cursor"')) {

return {

stdout: Buffer.from(`${workspaceDir}/note.txt\n`),

stderr: Buffer.alloc(0),

code: 0,

};

}

if (command.script.includes('stat -c "%F|%h"')) {

return {

stdout: Buffer.from("regular file|1\n"),

stderr: Buffer.alloc(0),

code: 0,

};

}

if (command.script.includes('stat -c "%F|%s|%y"')) {

return {

stdout: Buffer.from("regular file|12oops|not-a-date\n"),

stderr: Buffer.alloc(0),

code: 0,

};

}

throw new Error(`unexpected remote script: ${command.script}`);

},

};

const bridge = createRemoteShellSandboxFsBridge({

sandbox: createSandbox({

workspaceDir,

agentWorkspaceDir: workspaceDir,

}),

runtime,

});

await expect(bridge.stat({ filePath: "note.txt" })).resolves.toEqual({

type: "file",

size: 0,

mtimeMs: 0,

});

});

});

});

async function withTempDir<T>(prefix: string, run: (stateDir: string) => Promise<T>): Promise<T> {

} from "./backend-handle.types.js";

import { SANDBOX_PINNED_MUTATION_PYTHON } from "./fs-bridge-mutation-helper.js";

import { createWritableRenameTargetResolver } from "./fs-bridge-rename-targets.js";

import { parseSandboxStatMtimeMs, parseSandboxStatSize } from "./fs-bridge-stat-parse.js";

import type { SandboxFsBridge, SandboxFsStat, SandboxResolvedPath } from "./fs-bridge.types.js";

import {

isPathInsideContainerRoot,

} from "./path-utils.js";

import { isExistingWorkspaceSkillMountSource } from "./workspace-mounts.js";

function parseStatMtimeMs(value: string | undefined): number {

const raw = value ?? "0";

if (/^\d+(?:\.\d+)?$/.test(raw)) {

return Number(raw) * 1000;

}

const parsed = Date.parse(raw);

return Number.isFinite(parsed) ? parsed : 0;

}

type RemoteMountSource = "workspace" | "agent" | "protectedSkill";

type ResolvedRemotePath = SandboxResolvedPath & {

const [kindRaw = "", sizeRaw = "0", mtimeRaw = "0"] = output.split("|");

return {

type: kindRaw === "directory" ? "directory" : kindRaw === "regular file" ? "file" : "other",

size: Number(sizeRaw),

mtimeMs: parseStatMtimeMs(mtimeRaw),

size: parseSandboxStatSize(sizeRaw),

mtimeMs: parseSandboxStatMtimeMs(mtimeRaw),

};

}