mcp-perforce-server 3.0.0 → 3.2.0

package/dist/tools/basic.js

@@ -68,6 +68,7 @@ exports.p4Fstat = p4Fstat;
 exports.p4Streams = p4Streams;
 exports.p4Stream = p4Stream;
 const parse = __importStar(require("../p4/parse.js"));
+const arg_utils_js_1 = require("./arg-utils.js");
 /**
  * Input validation utilities
  */
@@ -160,11 +161,31 @@ async function p4Info(context, args = {}) {
  * p4 opened - List opened files
  */
 async function p4Opened(context, args = {}) {
+    if (args.files) {
+        const fileValidation = (0, arg_utils_js_1.sanitizeStringList)(context.security, args.files, 'filespec', 'files');
+        if (!fileValidation.valid) {
+            return {
+                ok: false,
+                command: 'opened',
+                args: [],
+                cwd: process.cwd(),
+                configUsed: {},
+                error: {
+                    code: 'P4_INVALID_ARGS',
+                    message: fileValidation.error || 'Invalid files',
+                },
+            };
+        }
+    }
     const { cwd, env, configResult } = await context.config.setupForCommand(args.workspacePath);
     const cmdArgs = [];
     if (args.changelist) {
         cmdArgs.push('-c', args.changelist);
     }
+    if (args.files && args.files.length > 0) {
+        const fileValidation = (0, arg_utils_js_1.sanitizeStringList)(context.security, args.files, 'filespec', 'files');
+        cmdArgs.push(...(fileValidation.values || []));
+    }
     const result = await context.runner.run('opened', cmdArgs, cwd, {
         env,
         useZtag: false,
@@ -468,6 +489,50 @@ async function p4Revert(context, args = {}) {
  * p4 sync - Sync files from depot
  */
 async function p4Sync(context, args = {}) {
+    const filespecs = (0, arg_utils_js_1.mergeStringArgs)(args.filespec, args.filespecs);
+    if (filespecs.length > 0) {
+        const filespecValidation = (0, arg_utils_js_1.sanitizeStringList)(context.security, filespecs, 'filespec', 'filespecs');
+        if (!filespecValidation.valid) {
+            return {
+                ok: false,
+                command: 'sync',
+                args: [],
+                cwd: process.cwd(),
+                configUsed: {},
+                error: {
+                    code: 'P4_INVALID_ARGS',
+                    message: filespecValidation.error || 'Invalid filespecs',
+                },
+            };
+        }
+    }
+    const modeFlags = [args.metadataOnly, args.safeSync, args.populateOnly].filter(Boolean).length;
+    if (modeFlags > 1) {
+        return {
+            ok: false,
+            command: 'sync',
+            args: [],
+            cwd: process.cwd(),
+            configUsed: {},
+            error: {
+                code: 'P4_INVALID_ARGS',
+                message: 'metadataOnly, safeSync, and populateOnly are mutually exclusive',
+            },
+        };
+    }
+    if (args.preview && args.summaryPreview) {
+        return {
+            ok: false,
+            command: 'sync',
+            args: [],
+            cwd: process.cwd(),
+            configUsed: {},
+            error: {
+                code: 'P4_INVALID_ARGS',
+                message: 'preview and summaryPreview cannot both be true',
+            },
+        };
+    }
     const { cwd, env, configResult } = await context.config.setupForCommand(args.workspacePath);
     const cmdArgs = [];
     if (args.force) {
@@ -476,8 +541,36 @@ async function p4Sync(context, args = {}) {
     if (args.preview) {
         cmdArgs.push('-n');
     }
-    if (args.filespec) {
-        cmdArgs.push(args.filespec);
+    if (args.summaryPreview) {
+        cmdArgs.push('-N');
+    }
+    if (args.quiet) {
+        cmdArgs.push('-q');
+    }
+    if (args.metadataOnly) {
+        cmdArgs.push('-k');
+    }
+    if (args.safeSync) {
+        cmdArgs.push('-s');
+    }
+    if (args.populateOnly) {
+        cmdArgs.push('-p');
+    }
+    if (args.reopenMoved) {
+        cmdArgs.push('-r');
+    }
+    if (args.useListOptimization) {
+        cmdArgs.push('-L');
+    }
+    if (args.max && args.max > 0) {
+        cmdArgs.push('-m', args.max.toString());
+    }
+    if (args.parallel) {
+        cmdArgs.push(`--parallel=${args.parallel}`);
+    }
+    if (filespecs.length > 0) {
+        const filespecValidation = (0, arg_utils_js_1.sanitizeStringList)(context.security, filespecs, 'filespec', 'filespecs');
+        cmdArgs.push(...(filespecValidation.values || []));
     }
     const result = await context.runner.run('sync', cmdArgs, cwd, {
         env,
@@ -784,6 +877,23 @@ async function p4Unshelve(context, args) {
  * p4 changes - List submitted changelists (enhanced version)
  */
 async function p4Changes(context, args = {}) {
+    const filespecs = (0, arg_utils_js_1.mergeStringArgs)(args.filespec, args.filespecs);
+    if (filespecs.length > 0) {
+        const filespecValidation = (0, arg_utils_js_1.sanitizeStringList)(context.security, filespecs, 'filespec', 'filespecs');
+        if (!filespecValidation.valid) {
+            return {
+                ok: false,
+                command: 'changes',
+                args: [],
+                cwd: process.cwd(),
+                configUsed: {},
+                error: {
+                    code: 'P4_INVALID_ARGS',
+                    message: filespecValidation.error || 'Invalid filespecs',
+                },
+            };
+        }
+    }
     const { cwd, env, configResult } = await context.config.setupForCommand(args.workspacePath);
     const cmdArgs = [];
     // Add status filter
@@ -803,8 +913,9 @@ async function p4Changes(context, args = {}) {
         cmdArgs.push('-m', args.max.toString());
     }
     // Add filespec
-    if (args.filespec) {
-        cmdArgs.push(args.filespec);
+    if (filespecs.length > 0) {
+        const filespecValidation = (0, arg_utils_js_1.sanitizeStringList)(context.security, filespecs, 'filespec', 'filespecs');
+        cmdArgs.push(...(filespecValidation.values || []));
     }
     const result = await context.runner.run('changes', cmdArgs, cwd, {
         env,
@@ -976,7 +1087,10 @@ async function p4Reviews(context, args = {}) {
  * p4 interchanges - List changelists not yet integrated between paths
  */
 async function p4Interchanges(context, args) {
-    if (!args.sourcePath || !args.targetPath) {
+    const targetPaths = (0, arg_utils_js_1.mergeStringArgs)(args.targetPath, args.targetPaths);
+    const usingPathMode = !args.branch && !args.stream && !!args.sourcePath && targetPaths.length > 0;
+    const modeCount = [usingPathMode, !!args.branch, !!args.stream].filter(Boolean).length;
+    if (modeCount !== 1) {
         return {
             ok: false,
             command: 'interchanges',
@@ -985,13 +1099,71 @@ async function p4Interchanges(context, args) {
             configUsed: {},
             error: {
                 code: 'P4_INVALID_ARGS',
-                message: 'sourcePath and targetPath parameters are required',
+                message: 'Provide exactly one interchanges mode: sourcePath+targetPath(s), branch, or stream',
             },
         };
     }
-    const sourceSanitization = context.security.sanitizeInput(args.sourcePath, 'filespec');
-    const targetSanitization = context.security.sanitizeInput(args.targetPath, 'filespec');
-    if (!sourceSanitization.valid || !targetSanitization.valid) {
+    if (args.useBranchSource && !args.branch) {
+        return {
+            ok: false,
+            command: 'interchanges',
+            args: [],
+            cwd: process.cwd(),
+            configUsed: {},
+            error: {
+                code: 'P4_INVALID_ARGS',
+                message: 'useBranchSource requires branch mode',
+            },
+        };
+    }
+    if (args.parentStream && !args.stream) {
+        return {
+            ok: false,
+            command: 'interchanges',
+            args: [],
+            cwd: process.cwd(),
+            configUsed: {},
+            error: {
+                code: 'P4_INVALID_ARGS',
+                message: 'parentStream requires stream mode',
+            },
+        };
+    }
+    if (args.forceStreamFlow && !args.stream) {
+        return {
+            ok: false,
+            command: 'interchanges',
+            args: [],
+            cwd: process.cwd(),
+            configUsed: {},
+            error: {
+                code: 'P4_INVALID_ARGS',
+                message: 'forceStreamFlow requires stream mode',
+            },
+        };
+    }
+    let sourceSanitized;
+    if (args.sourcePath) {
+        const sourceSanitization = context.security.sanitizeInput(args.sourcePath, 'filespec');
+        if (!sourceSanitization.valid) {
+            return {
+                ok: false,
+                command: 'interchanges',
+                args: [],
+                cwd: process.cwd(),
+                configUsed: {},
+                error: {
+                    code: 'P4_INVALID_ARGS',
+                    message: `Invalid sourcePath: ${sourceSanitization.warnings.join(', ')}`,
+                },
+            };
+        }
+        sourceSanitized = sourceSanitization.sanitized;
+    }
+    const targetValidation = targetPaths.length > 0
+        ? (0, arg_utils_js_1.sanitizeStringList)(context.security, targetPaths, 'filespec', 'targetPaths')
+        : { valid: true, values: [] };
+    if (!targetValidation.valid) {
         return {
             ok: false,
             command: 'interchanges',
@@ -1000,7 +1172,7 @@ async function p4Interchanges(context, args) {
             configUsed: {},
             error: {
                 code: 'P4_INVALID_ARGS',
-                message: 'Invalid sourcePath or targetPath filespec',
+                message: targetValidation.error || 'Invalid targetPaths',
             },
         };
     }
@@ -1012,7 +1184,55 @@ async function p4Interchanges(context, args) {
     if (args.max && args.max > 0) {
         cmdArgs.push('-m', args.max.toString());
     }
-    cmdArgs.push(sourceSanitization.sanitized, targetSanitization.sanitized);
+    if (args.reverse) {
+        cmdArgs.push('-r');
+    }
+    if (args.time) {
+        cmdArgs.push('-t');
+    }
+    if (args.user) {
+        cmdArgs.push('-u', args.user);
+    }
+    if (args.stream) {
+        cmdArgs.push('-S', args.stream);
+        if (args.parentStream) {
+            cmdArgs.push('-P', args.parentStream);
+        }
+        if (args.forceStreamFlow) {
+            cmdArgs.push('-F');
+        }
+        if (targetValidation.values && targetValidation.values.length > 0) {
+            cmdArgs.push(...targetValidation.values);
+        }
+    }
+    else if (args.branch) {
+        cmdArgs.push('-b', args.branch);
+        if (args.useBranchSource) {
+            if (!sourceSanitized) {
+                return {
+                    ok: false,
+                    command: 'interchanges',
+                    args: [],
+                    cwd: process.cwd(),
+                    configUsed: {},
+                    error: {
+                        code: 'P4_INVALID_ARGS',
+                        message: 'sourcePath is required when useBranchSource is true',
+                    },
+                };
+            }
+            cmdArgs.push('-s', sourceSanitized);
+            if (targetValidation.values && targetValidation.values.length > 0) {
+                cmdArgs.push(...targetValidation.values);
+            }
+        }
+        else if (targetValidation.values && targetValidation.values.length > 0) {
+            cmdArgs.push(...targetValidation.values);
+        }
+    }
+    else {
+        cmdArgs.push(sourceSanitized, ...(targetValidation.values || []));
+    }
     const result = await context.runner.run('interchanges', cmdArgs, cwd, {
         env,
         useZtag: false,
@@ -1039,7 +1259,7 @@ async function p4Interchanges(context, args) {
  * p4 integrated - Show integration history between paths
  */
 async function p4Integrated(context, args) {
-    if (!args.sourcePath) {
+    if (!args.sourcePath && (!args.files || args.files.length === 0)) {
         return {
             ok: false,
             command: 'integrated',
@@ -1048,23 +1268,27 @@ async function p4Integrated(context, args) {
             configUsed: {},
             error: {
                 code: 'P4_INVALID_ARGS',
-                message: 'sourcePath parameter is required',
+                message: 'sourcePath or files parameter is required',
             },
         };
     }
-    const sourceSanitization = context.security.sanitizeInput(args.sourcePath, 'filespec');
-    if (!sourceSanitization.valid) {
-        return {
-            ok: false,
-            command: 'integrated',
-            args: [],
-            cwd: process.cwd(),
-            configUsed: {},
-            error: {
-                code: 'P4_INVALID_ARGS',
-                message: `Invalid sourcePath: ${sourceSanitization.warnings.join(', ')}`,
-            },
-        };
+    let sourceSanitized;
+    if (args.sourcePath) {
+        const sourceSanitization = context.security.sanitizeInput(args.sourcePath, 'filespec');
+        if (!sourceSanitization.valid) {
+            return {
+                ok: false,
+                command: 'integrated',
+                args: [],
+                cwd: process.cwd(),
+                configUsed: {},
+                error: {
+                    code: 'P4_INVALID_ARGS',
+                    message: `Invalid sourcePath: ${sourceSanitization.warnings.join(', ')}`,
+                },
+            };
+        }
+        sourceSanitized = sourceSanitization.sanitized;
     }
     let targetSanitized;
     if (args.targetPath) {
@@ -1084,10 +1308,34 @@ async function p4Integrated(context, args) {
         }
         targetSanitized = targetSanitization.sanitized;
     }
+    let filesSanitized = [];
+    if (args.files && args.files.length > 0) {
+        const fileValidation = (0, arg_utils_js_1.sanitizeStringList)(context.security, args.files, 'filespec', 'files');
+        if (!fileValidation.valid) {
+            return {
+                ok: false,
+                command: 'integrated',
+                args: [],
+                cwd: process.cwd(),
+                configUsed: {},
+                error: {
+                    code: 'P4_INVALID_ARGS',
+                    message: fileValidation.error || 'Invalid files',
+                },
+            };
+        }
+        filesSanitized = fileValidation.values || [];
+    }
     const { cwd, env, configResult } = await context.config.setupForCommand(args.workspacePath);
-    const cmdArgs = [sourceSanitization.sanitized];
-    if (targetSanitized) {
-        cmdArgs.push(targetSanitized);
+    const cmdArgs = [];
+    if (sourceSanitized) {
+        cmdArgs.push(sourceSanitized);
+        if (targetSanitized) {
+            cmdArgs.push(targetSanitized);
+        }
+    }
+    if (filesSanitized.length > 0) {
+        cmdArgs.push(...filesSanitized);
     }
     const result = await context.runner.run('integrated', cmdArgs, cwd, {
         env,
@@ -1115,7 +1363,22 @@ async function p4Integrated(context, args) {
  * p4 blame - Show file annotations with change history
  */
 async function p4Blame(context, args) {
-    if (!args.file) {
+    const files = (0, arg_utils_js_1.mergeStringArgs)(args.file, args.files);
+    if (files.length === 0) {
+        return {
+            ok: false,
+            command: 'blame',
+            args: [],
+            cwd: process.cwd(),
+            configUsed: {},
+            error: {
+                code: 'P4_INVALID_ARGS',
+                message: 'file or files parameter is required',
+            },
+        };
+    }
+    const fileValidation = (0, arg_utils_js_1.sanitizeStringList)(context.security, files, 'filespec', 'files');
+    if (!fileValidation.valid) {
         return {
             ok: false,
             command: 'blame',
@@ -1124,12 +1387,12 @@ async function p4Blame(context, args) {
             configUsed: {},
             error: {
                 code: 'P4_INVALID_ARGS',
-                message: 'file parameter is required',
+                message: fileValidation.error || 'Invalid files',
             },
         };
     }
     const { cwd, env, configResult } = await context.config.setupForCommand(args.workspacePath);
-    const result = await context.runner.run('annotate', ['-a', args.file], cwd, {
+    const result = await context.runner.run('annotate', ['-a', ...(fileValidation.values || [])], cwd, {
         env,
         useZtag: false,
         parseOutput: false,
@@ -1343,10 +1606,10 @@ async function p4Grep(context, args) {
             },
         };
     }
-    let sanitizedFilespec = args.filespec;
-    if (args.filespec) {
-        const filespecSanitization = context.security.sanitizeInput(args.filespec, 'filespec');
-        if (!filespecSanitization.valid) {
+    const filespecs = (0, arg_utils_js_1.mergeStringArgs)(args.filespec, args.filespecs);
+    if (filespecs.length > 0) {
+        const filespecValidation = (0, arg_utils_js_1.sanitizeStringList)(context.security, filespecs, 'filespec', 'filespecs');
+        if (!filespecValidation.valid) {
             return {
                 ok: false,
                 command: 'grep',
@@ -1355,11 +1618,10 @@ async function p4Grep(context, args) {
                 configUsed: {},
                 error: {
                     code: 'P4_INVALID_ARGS',
-                    message: `Invalid filespec: ${filespecSanitization.warnings.join(', ')}`,
+                    message: filespecValidation.error || 'Invalid filespecs',
                 },
             };
         }
-        sanitizedFilespec = filespecSanitization.sanitized;
     }
     const { cwd, env, configResult } = await context.config.setupForCommand(args.workspacePath);
     const cmdArgs = [];
@@ -1367,8 +1629,9 @@ async function p4Grep(context, args) {
         cmdArgs.push('-i');
     }
     cmdArgs.push('-e', patternSanitization.sanitized);
-    if (sanitizedFilespec) {
-        cmdArgs.push(sanitizedFilespec);
+    if (filespecs.length > 0) {
+        const filespecValidation = (0, arg_utils_js_1.sanitizeStringList)(context.security, filespecs, 'filespec', 'filespecs');
+        cmdArgs.push(...(filespecValidation.values || []));
     }
     const result = await context.runner.run('grep', cmdArgs, cwd, {
         env,
@@ -1388,11 +1651,10 @@ async function p4Grep(context, args) {
  * p4 files - List files in depot with metadata
  */
 async function p4Files(context, args) {
-    // Input sanitization for filespec
-    let sanitizedFilespec = args.filespec || '...';
-    if (args.filespec) {
-        const filespecSanitization = context.security.sanitizeInput(args.filespec, 'filespec');
-        if (!filespecSanitization.valid) {
+    const filespecs = (0, arg_utils_js_1.mergeStringArgs)(args.filespec, args.filespecs);
+    if (filespecs.length > 0) {
+        const filespecValidation = (0, arg_utils_js_1.sanitizeStringList)(context.security, filespecs, 'filespec', 'filespecs');
+        if (!filespecValidation.valid) {
             return {
                 ok: false,
                 command: 'files',
@@ -1401,18 +1663,23 @@ async function p4Files(context, args) {
                 configUsed: {},
                 error: {
                     code: 'P4_INVALID_ARGS',
-                    message: `Invalid filespec: ${filespecSanitization.warnings.join(', ')}`,
+                    message: filespecValidation.error || 'Invalid filespecs',
                 },
             };
         }
-        sanitizedFilespec = filespecSanitization.sanitized;
     }
     const { cwd, env, configResult } = await context.config.setupForCommand(args.workspacePath);
     const cmdArgs = [];
     if (args.max) {
         cmdArgs.push('-m', args.max.toString());
     }
-    cmdArgs.push(sanitizedFilespec);
+    if (filespecs.length > 0) {
+        const filespecValidation = (0, arg_utils_js_1.sanitizeStringList)(context.security, filespecs, 'filespec', 'filespecs');
+        cmdArgs.push(...(filespecValidation.values || []));
+    }
+    else {
+        cmdArgs.push('...');
+    }
     const result = await context.runner.run('files', cmdArgs, cwd, {
         env,
         useZtag: false,
@@ -1431,11 +1698,10 @@ async function p4Files(context, args) {
  * p4 dirs - List directories in depot
  */
 async function p4Dirs(context, args) {
-    // Input sanitization for filespec
-    let sanitizedFilespec = args.filespec || '...';
-    if (args.filespec) {
-        const filespecSanitization = context.security.sanitizeInput(args.filespec, 'filespec');
-        if (!filespecSanitization.valid) {
+    const filespecs = (0, arg_utils_js_1.mergeStringArgs)(args.filespec, args.filespecs);
+    if (filespecs.length > 0) {
+        const filespecValidation = (0, arg_utils_js_1.sanitizeStringList)(context.security, filespecs, 'filespec', 'filespecs');
+        if (!filespecValidation.valid) {
             return {
                 ok: false,
                 command: 'dirs',
@@ -1444,15 +1710,48 @@ async function p4Dirs(context, args) {
                 configUsed: {},
                 error: {
                     code: 'P4_INVALID_ARGS',
-                    message: `Invalid filespec: ${filespecSanitization.warnings.join(', ')}`,
+                    message: filespecValidation.error || 'Invalid filespecs',
                 },
             };
         }
-        sanitizedFilespec = filespecSanitization.sanitized;
+    }
+    if (args.ignoreCase && args.onlyClientMapped) {
+        return {
+            ok: false,
+            command: 'dirs',
+            args: [],
+            cwd: process.cwd(),
+            configUsed: {},
+            error: {
+                code: 'P4_INVALID_ARGS',
+                message: 'ignoreCase and onlyClientMapped cannot be combined',
+            },
+        };
     }
     const { cwd, env, configResult } = await context.config.setupForCommand(args.workspacePath);
     const cmdArgs = [];
-    cmdArgs.push(sanitizedFilespec);
+    if (args.onlyClientMapped) {
+        cmdArgs.push('-C');
+    }
+    if (args.includeDeleted) {
+        cmdArgs.push('-D');
+    }
+    if (args.onlyHave) {
+        cmdArgs.push('-H');
+    }
+    if (args.stream) {
+        cmdArgs.push('-S', args.stream);
+    }
+    if (args.ignoreCase) {
+        cmdArgs.push('-i');
+    }
+    if (filespecs.length > 0) {
+        const filespecValidation = (0, arg_utils_js_1.sanitizeStringList)(context.security, filespecs, 'filespec', 'filespecs');
+        cmdArgs.push(...(filespecValidation.values || []));
+    }
+    else {
+        cmdArgs.push('...');
+    }
     const result = await context.runner.run('dirs', cmdArgs, cwd, {
         env,
         useZtag: false,
@@ -1601,7 +1900,8 @@ async function p4Merge(context, args) {
  * p4 print - Print file contents from depot
  */
 async function p4Print(context, args) {
-    if (!args.filespec) {
+    const filespecs = (0, arg_utils_js_1.mergeStringArgs)(args.filespec, args.filespecs);
+    if (filespecs.length === 0) {
         return {
             ok: false,
             command: 'print',
@@ -1610,12 +1910,12 @@ async function p4Print(context, args) {
             configUsed: {},
             error: {
                 code: 'P4_INVALID_ARGS',
-                message: 'filespec parameter is required',
+                message: 'filespec or filespecs parameter is required',
             },
         };
     }
-    const filespecSanitization = context.security.sanitizeInput(args.filespec, 'filespec');
-    if (!filespecSanitization.valid) {
+    const filespecValidation = (0, arg_utils_js_1.sanitizeStringList)(context.security, filespecs, 'filespec', 'filespecs');
+    if (!filespecValidation.valid) {
         return {
             ok: false,
             command: 'print',
@@ -1624,7 +1924,7 @@ async function p4Print(context, args) {
             configUsed: {},
             error: {
                 code: 'P4_INVALID_ARGS',
-                message: `Invalid filespec: ${filespecSanitization.warnings.join(', ')}`,
+                message: filespecValidation.error || 'Invalid filespecs',
             },
         };
     }
@@ -1633,7 +1933,7 @@ async function p4Print(context, args) {
     if (args.quiet !== false) {
         cmdArgs.push('-q');
     }
-    cmdArgs.push(filespecSanitization.sanitized);
+    cmdArgs.push(...(filespecValidation.values || []));
     const result = await context.runner.run('print', cmdArgs, cwd, {
         env,
         useZtag: false,
@@ -1652,7 +1952,8 @@ async function p4Print(context, args) {
  * p4 fstat - Show file metadata from depot/workspace
  */
 async function p4Fstat(context, args) {
-    if (!args.filespec) {
+    const filespecs = (0, arg_utils_js_1.mergeStringArgs)(args.filespec, args.filespecs);
+    if (filespecs.length === 0) {
         return {
             ok: false,
             command: 'fstat',
@@ -1661,12 +1962,12 @@ async function p4Fstat(context, args) {
             configUsed: {},
             error: {
                 code: 'P4_INVALID_ARGS',
-                message: 'filespec parameter is required',
+                message: 'filespec or filespecs parameter is required',
             },
         };
     }
-    const filespecSanitization = context.security.sanitizeInput(args.filespec, 'filespec');
-    if (!filespecSanitization.valid) {
+    const filespecValidation = (0, arg_utils_js_1.sanitizeStringList)(context.security, filespecs, 'filespec', 'filespecs');
+    if (!filespecValidation.valid) {
         return {
             ok: false,
             command: 'fstat',
@@ -1675,16 +1976,62 @@ async function p4Fstat(context, args) {
             configUsed: {},
             error: {
                 code: 'P4_INVALID_ARGS',
-                message: `Invalid filespec: ${filespecSanitization.warnings.join(', ')}`,
+                message: filespecValidation.error || 'Invalid filespecs',
+            },
+        };
+    }
+    if (args.changeAfter && args.changelist) {
+        return {
+            ok: false,
+            command: 'fstat',
+            args: [],
+            cwd: process.cwd(),
+            configUsed: {},
+            error: {
+                code: 'P4_INVALID_ARGS',
+                message: 'changeAfter and changelist cannot both be specified',
             },
         };
     }
     const { cwd, env, configResult } = await context.config.setupForCommand(args.workspacePath);
     const cmdArgs = [];
+    if (args.filter) {
+        cmdArgs.push('-F', args.filter);
+    }
+    if (args.fields && args.fields.length > 0) {
+        cmdArgs.push('-T', args.fields.join(','));
+    }
     if (args.max) {
         cmdArgs.push('-m', args.max.toString());
     }
-    cmdArgs.push(filespecSanitization.sanitized);
+    if (args.reverseOrder) {
+        cmdArgs.push('-r');
+    }
+    if (args.changeAfter) {
+        cmdArgs.push('-c', args.changeAfter);
+    }
+    if (args.changelist) {
+        cmdArgs.push('-e', args.changelist);
+    }
+    if (args.attributePattern) {
+        cmdArgs.push('-A', args.attributePattern);
+    }
+    if (args.outputOptions) {
+        for (const option of args.outputOptions) {
+            cmdArgs.push(`-O${option}`);
+        }
+    }
+    if (args.limitOptions) {
+        for (const option of args.limitOptions) {
+            cmdArgs.push(`-R${option}`);
+        }
+    }
+    if (args.sortOptions) {
+        for (const option of args.sortOptions) {
+            cmdArgs.push(`-S${option}`);
+        }
+    }
+    cmdArgs.push(...(filespecValidation.values || []));
     const result = await context.runner.run('fstat', cmdArgs, cwd, {
         env,
         useZtag: true,
@@ -1703,13 +2050,56 @@ async function p4Fstat(context, args) {
  * p4 streams - List streams
  */
 async function p4Streams(context, args = {}) {
+    const streams = (0, arg_utils_js_1.mergeStringArgs)(args.stream, args.streams);
+    if (streams.length > 0) {
+        const streamValidation = (0, arg_utils_js_1.sanitizeStringList)(context.security, streams, 'filespec', 'streams');
+        if (!streamValidation.valid) {
+            return {
+                ok: false,
+                command: 'streams',
+                args: [],
+                cwd: process.cwd(),
+                configUsed: {},
+                error: {
+                    code: 'P4_INVALID_ARGS',
+                    message: streamValidation.error || 'Invalid streams',
+                },
+            };
+        }
+    }
     const { cwd, env, configResult } = await context.config.setupForCommand(args.workspacePath);
     const cmdArgs = [];
+    if (args.unloaded) {
+        cmdArgs.push('-U');
+    }
+    if (args.filter) {
+        cmdArgs.push('-F', args.filter);
+    }
     if (args.max) {
         cmdArgs.push('-m', args.max.toString());
     }
-    if (args.stream) {
-        cmdArgs.push(args.stream);
+    if (args.viewMatch) {
+        const viewMatchValidation = (0, arg_utils_js_1.sanitizeStringList)(context.security, args.viewMatch, 'filespec', 'viewMatch');
+        if (!viewMatchValidation.valid) {
+            return {
+                ok: false,
+                command: 'streams',
+                args: [],
+                cwd: process.cwd(),
+                configUsed: {},
+                error: {
+                    code: 'P4_INVALID_ARGS',
+                    message: viewMatchValidation.error || 'Invalid viewMatch',
+                },
+            };
+        }
+        for (const viewMatch of viewMatchValidation.values || []) {
+            cmdArgs.push('--viewmatch', viewMatch);
+        }
+    }
+    if (streams.length > 0) {
+        const streamValidation = (0, arg_utils_js_1.sanitizeStringList)(context.security, streams, 'filespec', 'streams');
+        cmdArgs.push(...(streamValidation.values || []));
     }
     const result = await context.runner.run('streams', cmdArgs, cwd, {
         env,