Replacing Return to Homescreen with Exit Shortcut upon shortcut import

%hookWFSharedShortcut
-(WFWorkflowRecord*)workflowRecord{
/* WFWorkflowRecord handles how shortcuts are stored and hooking it will affect every shortcut loaded - not only is this bad for performance, but if you make a mistake, every shortcut will be affected, hence it's best to avoid hooking it when possible. Here, we hook WFSharedShortcut and affect its workflow record instead */
WFWorkflowRecord*workflowRecord=%orig;
NSArray*workflowRecordActions=[workflowRecordactions];
NSMutableArray*newMutableShortcutActions=[workflowRecordActionsmutableCopy];
unsignedintshortcutActionsObjectIndex=0;

for(idshortcutActionsObjectinworkflowRecordActions){
if([shortcutActionsObjectisKindOfClass:[NSDictionaryclass]]){
NSString*actionIdentifier=shortcutActionsObject[@"WFWorkflowActionIdentifier"];
if(actionIdentifier){
/* All shortcuts have an identifier to help identify the action (is.workflow.actions.returntohomescreen is Return to Homescreen, is.workflow.actions.exit is Exit Shortcut). You can find the default action identifiers in /System/​Library/​PrivateFrameworks/​WorkflowKit.framework/WFActions.plist */
if([actionIdentifierisEqualToString:@"is.workflow.actions.returntohomescreen"]){
NSMutableDictionary*mutableShortcutActionsObject=[shortcutActionsObjectmutableCopy];
/* While not demo'ed in this example, actions also have WFWorkflowActionParameters. For example, the file path in Get File is the WFGetFilePath parameter. These can also be found in WFActions.plist, or by extracting an unsigned .shortcut/.wflow file and looking to see the parameters of the action in the shortcut. */

mutableShortcutActionsObject[@"WFWorkflowActionIdentifier"]=@"is.workflow.actions.exit";

newMutableShortcutActions[shortcutActionsObjectIndex]=[[NSDictionaryalloc]initWithDictionary:mutableShortcutActionsObject];
}
}
}
shortcutActionsObjectIndex++;
}

[workflowRecordsetActions:newMutableShortcutActions];
returnworkflowRecord;
}
%end

Iterating through all actions being loaded

%hookWFBundledActionProvider
-(id)createAllAvailableActions{
idcreateactions=%orig;//__NSSetM
for(WFAction*newCreateActionincreateactions){
NSLog(@"Shortcut Action identifier: %@",[newCreateActionidentifier]);
if([[newCreateActionidentifier]isEqualToString:@"is.workflow.actions.exit"]){
// the action being iterated has the action identifier of is.workflow.actions.exit - this means we found the exit shortcut action!
NSLog(@"Exit action: %@",newCreateAction);
}
}

returncreateactions;
}
%end

Importing an unsigned shortcut from a file path (iOS 15+)

WFFileRepresentation*fileRep=[WFFileRepresentationfileWithURL:[NSURLfileURLWithPath:@"/path/to/unsignedShortcut.shortcut"]options:nil];
WFWorkflowFileDescriptor*fileDesc=[[WFWorkflowFileDescriptoralloc]initWithFile:[shortcutExtractorextractingFile]name:@"SnoolieShortcut"];
WFWorkflowFile*wFile=[[WFWorkflowFilealloc]initWithDescriptor:fileDescerror:nil];
WFWorkflowRecord*workflowRecord=[wFilerecordRepresentationWithError:nil];/* requires cloudkit entitlement */
/* now actually add shortcut to database */
WFDatabaseProxy*databaseProxy=[[WFDatabaseProxyalloc]initWithDatabase:[WFDatabasedefaultDatabase]];
[databaseProxycreateWorkflowWithWorkflowRecord:workflowRecordnameCollisionBehavior:0x0error:nil];

iCloud-Signing an unsigned shortcut (iOS 13+)

WFFileRepresentation*fileRep=[WFFileRepresentationfileWithURL:[NSURLfileURLWithPath:@"/path/to/unsignedShortcut.shortcut"]options:nil];
WFWorkflowFileDescriptor*fileDesc=[[WFWorkflowFileDescriptoralloc]initWithFile:[shortcutExtractorextractingFile]name:@"SnoolieShortcut"];
WFWorkflowFile*wFile=[[WFWorkflowFilealloc]initWithDescriptor:fileDescerror:nil];
WFWorkflowRecord*workflowRecord=[wFilerecordRepresentationWithError:nil];/* requires cloudkit entitlement */
/* now actually sign shortcut */
/*
 * iOS 15 has two classes in relating to iCloud signing:
 * WFiCloudShortcutFileExporter (the one actually used in the macOS CLI tool, outputs signed file)
 * WFShortcutiCloudLinkExporter (outputs iCloud URL)
 * However, both of these are just wrappers around WFGallerySessionManager
 * since its methods exist in iOS 13/14, it can easily be backported to those versions
 * here, I call uploadWorkflow: just like the normal implementation, however
 * the normal implementation of WFiCloudShortcutFileExporter parses the file URL
 * to get the shortcut identifier, then calls getWorkflowForIdentifier
 * I'm not sure what this method does exactly, but it is on iOS 13, however I was worried it
 * might not return signing information on iOS 13, so to be safe, instead I parse the iCloud
 * URL that is returned, and use the iCloud API to retrive the signed shortcut file.
 * Also, note I only tested this when being injected into the Shortcuts process :P.
*/
WFGallerySessionManager*sharedManager=[WFGallerySessionManagersharedManager];
WFFileRepresentation*fileRep=[WFFileRepresentationfileWithURL:[NSURLfileURLWithPath:@"/path/to/unsignedShortcut.shortcut"]options:nil];
[sharedManageruploadWorkflow:workflowRecordwithName:@"Signed Shortcut Test"shortDescription:nillongDescription:nilprivate:YEScompletionHandler:^(NSURL*iCloudURLToShortcut,idexportError){
if(!exportError){
if(iCloudURLToShortcut){
/*
 * iCloudURLToShortcut will be https://www.icloud.com/shortcuts/(shortcutid)
 * We need to get https://www.icloud.com/shortcuts/api/records/(shortcutid)
 * This will have the URL to the signed shortcut file.
 */
NSString*apiURLString=[iCloudURLToShortcut.absoluteStringstringByReplacingOccurrencesOfString:@"/shortcuts/"withString:@"/shortcuts/api/records/"];
NSData*jsonData=[NSDatadataWithContentsOfURL:[NSURLURLWithString:apiURLString]];
NSError*jsonError=nil;
NSDictionary*apiResponse=[NSJSONSerializationJSONObjectWithData:jsonDataoptions:0error:&jsonError];
if(!jsonError){
/* you probably should check for nil with these keys instead of just blindly trusting they all exist but eh, this is just a quick PoC */
NSString*signedShortcutURL=apiResponse[@"fields"][@"signedShortcut"][@"value"][@"downloadURL"];
NSURL*dataGetURL=[[NSURLalloc]initWithString:[signedShortcutURLstringByAddingPercentEscapesUsingEncoding:NSASCIIStringEncoding]];
NSData*signedShortcutData=[NSDatadataWithContentsOfURL:dataGetURL];
[signedShortcutDatawriteToFile:@"/path/to/output/the/signedShortcut.shortcut"atomically:YES];
}else{
/* handle json error */
NSLog(@"ShortcutsCLI-iOS(jsonError): %@",jsonError);
}
}else{
/* both exportError and iCloudURLToShortcut are nil?? */
NSLog(@"ShortcutsCLI-iOS Error: nil but no err?");
}
}else{
/* Handle errors with iCloud uploading */
NSLog(@"ShortcutsCLI-iOS Error: %@",exportError);
}
}];

Contact-Signing an unsigned shortcut (iOS 15+)

WFFileRepresentation*fileRep=[WFFileRepresentationfileWithURL:[NSURLfileURLWithPath:@"/path/to/unsignedShortcut.shortcut"]options:nil];
WFWorkflowFileDescriptor*fileDesc=[[WFWorkflowFileDescriptoralloc]initWithFile:[shortcutExtractorextractingFile]name:@"SnoolieShortcut"];
WFWorkflowFile*wFile=[[WFWorkflowFilealloc]initWithDescriptor:fileDescerror:nil];
WFWorkflowRecord*workflowRecord=[wFilerecordRepresentationWithError:nil];/* requires cloudkit entitlement */
/* now actually sign shortcut */
WFP2PSignedShortcutFileExporter*contactExporter=[[WFP2PSignedShortcutFileExporteralloc]initWithWorkflowRecord:workflowRecord];
[contactExporterexportWorkflowWithCompletion:^(idarg0,idarg1){
/*
 * What you *should* do, and what the normal cli
 * for macOS does is to use the result from
 * the completion method. I'm not for contact
 * signed, but however contact signed shortcuts
 * should store the result in the property
 * afterwards anyway, which I'm just using
 * that here, so it should be fine.
 */
NSLog(@"Completion block called (not used here)");
}];
/* This is fine (for contact signed) */
WFFileRepresentation*signedShortcutFile=[contactExportersignedShortcutFile];
NSData*signedShortcutFileData=[signedShortcutFiledata];
[signedShortcutFileDatawriteToFile:someFileURLToOutputSignedShortcutatomically:YES];

iCloud-Signing an unsigned shortcut using WFiCloudShortcutFileExporter (iOS 15+)

WFFileRepresentation*fileRep=[WFFileRepresentationfileWithURL:[NSURLfileURLWithPath:@"/path/to/unsignedShortcut.shortcut"]options:nil];
WFWorkflowFileDescriptor*fileDesc=[[WFWorkflowFileDescriptoralloc]initWithFile:[shortcutExtractorextractingFile]name:@"SnoolieShortcut"];
WFWorkflowFile*wFile=[[WFWorkflowFilealloc]initWithDescriptor:fileDescerror:nil];
WFWorkflowRecord*workflowRecord=[wFilerecordRepresentationWithError:nil];/* requires cloudkit entitlement */
/* now actually sign shortcut */
WFiCloudShortcutFileExporter*icloudExporter=[[WFiCloudShortcutFileExporteralloc]initWithWorkflowRecord:workflowRecord];
[icloudExporterexportWorkflowWithCompletion:^(idfileURLToiCloudSignedShortcut,idexportError){
/*
 * Unlike contact-signed, we *need* to use
 * the completion block here. While
 * WFiCloudShortcutFileExporter does also
 * have a signedShortcutFile property,
 * either it's never set, or trying to
 * get it right after can cause some race
 * conditions (which juding by how
 * [icloudExporter signedShortcutFile];
 * seemed to be called after the completion
 * block was called to my testing, it very
 * well could be race conditions). The
 * first arg will be a file:/// URL to
 * a temp directory storing the signed shortcut
 * file. exportError will be null unless there's
 * an error. If there's an error, the first arg
 * will be null.
 */
NSLog(@"Completion block called");
if(!exportError){
/* do cool stuff */
}else{
/* Handle errors */
NSLog(@"ShortcutsCLI-iOS Error: %@",exportError);
}
}];

iOS 13/14 Backport of WFShortcutiCloudLinkExporter

@interface WFShortcutiCloudLinkExporter : NSObject
@property(nonatomic,readonly)WFWorkflowRecord*workflowRecord;
-(void)exportWorkflowWithCompletion:(id)completion;
-(instancetype)initWithWorkflowRecord:(WFWorkflowRecord*)workflowRecord;
-(instancetype)initWithWorkflowRecord:(WFWorkflowRecord*)workflowRecordsharingOptions:(id)argWeDontCareAbout;
@end
@implementation WFShortcutiCloudLinkExporter
-(instancetype)initWithWorkflowRecord:(WFWorkflowRecord*)workflowRecord{
self=[superinit];
if(self){
_workflowRecord=workflowRecord;
}
returnself;
}
-(instancetype)initWithWorkflowRecord:(WFWorkflowRecord*)workflowRecordsharingOptions:(id)argWeDontCareAbout{
/* the normal implementation of this in WFShortcutExporter calls prepareForSharingWithOptions but for just backporting WFShortcutiCloudLinkExporter we dont care about that */
return[selfinitWithWorkflowRecord:workflowRecord];
}
-(void)exportWorkflowWithCompletion:(id)completion{
WFGallerySessionManager*sharedManager=[WFGallerySessionManagersharedManager];
WFWorkflowRecord*workflowRecord=[selfworkflowRecord];
/* Here's a fun fact! This backport should be a bit more optimized than the normal way (though it's so minor that you'll see no difference) as the actual implementation in iOS 15 calls [self workflowRecord] twice since it recalls it to get the name, but this implementation only calls it once */
[sharedManageruploadWorkflow:workflowRecordwithName:[workflowRecordname]shortDescription:nillongDescription:nilprivate:YEScompletionHandler:completion];
}
@end