1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# [Optional]: Working directories SIERRA will try as cwd when executing Command
# These entries are not executable search roots
PATHS: 
    - /path/to/script/directory
    - /another/path
    
# [Mandatory]: Contains the list of Invoker scripts
SCRIPTS:
  - Name: Unique Script Name  # [Mandatory]
    Description: Brief description of the script
    Protocol: V2  # [Optional] omit for V1 batch invokers
    Params:  # [Mandatory]
      - Name: ParameterName  # [Mandatory]
        Description: Parameter description  # [Optional]
        # [Mandatory]: The data type of the parameter
        # User-facing types: STRING, FILE, IMAGE, COLLECTION
        Type: STRING
        Options:  # [Optional]
          - MANDATORY # indicates this parameter cannot be empty
    Command: command_to_execute {ParameterName}  # [Mandatory]

1
2
3
4
5
6
7
8
9
10
SCRIPTS:
  - Name: OCR Screenshot
    Description: Read text from an image
    Params:
      - Name: Image
        Description: Clipboard image, local file, or remote image URL
        Type: IMAGE
        Options:
          - MANDATORY
    Command: python ocr_image.py "{Image}"

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import json
import sys
from pathlib import Path

image_path = Path(sys.argv[1])

if not image_path.is_file():
    print(json.dumps({
        "type": "Error",
        "message": "Image file was not found",
    }))
    raise SystemExit(0)

image_bytes = image_path.read_bytes()
print(json.dumps({
    "type": "Tree",
    "results": [
        f"# OCR Image\n{image_path.name}",
        f"Loaded {len(image_bytes)} bytes from {image_path}",
    ],
}))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
{
  "kind": "collection",
  "title": "Case Evidence",
  "nodes": [
    {
      "id": "domain-node",
      "type": "entity",
      "position": { "x": 0, "y": 0 },
      "data": { "content": "example.com" }
    },
    {
      "id": "child-collection",
      "type": "collectionEntity",
      "position": { "x": 220, "y": 0 },
      "data": { "title": "Login hosts" }
    },
    {
      "id": "login-node",
      "type": "entity",
      "parentId": "child-collection",
      "position": { "x": 24, "y": 72 },
      "data": { "content": "https://login.example.com" }
    }
  ],
  "edges": [
    {
      "id": "edge-1",
      "source": "domain-node",
      "target": "login-node",
      "data": { "text": "expands to" }
    }
  ]
}

1
2
3
4
5
6
7
8
9
10
SCRIPTS:
  - Name: Collection Brief
    Description: Summarize a selected collection's nodes and relationships
    Params:
      - Name: Collection
        Description: Collection node to summarize
        Type: COLLECTION
        Options:
          - MANDATORY
    Command: python summarize_collection.py "@{Collection_JSON_FILE}"

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
import json
import sys
from pathlib import Path

def load_collection(raw_value):
    raw_value = raw_value.strip()
    if raw_value.startswith("@"):
        return json.loads(Path(raw_value[1:]).read_text(encoding="utf-8"))
    return json.loads(raw_value)

try:
    collection = load_collection(sys.argv[1])
except Exception as exc:
    print(json.dumps({
        "type": "Error",
        "message": f"Could not read collection input: {exc}",
    }))
    raise SystemExit(0)

if collection.get("kind") != "collection":
    print(json.dumps({
        "type": "Error",
        "message": "Expected a COLLECTION input from SIERRA.",
    }))
    raise SystemExit(0)

nodes = collection.get("nodes", [])
edges = collection.get("edges", [])
node_by_id = {node.get("id"): node for node in nodes}

def node_label(node):
    data = node.get("data") or {}
    return data.get("title") or data.get("content") or node.get("id") or "Untitled node"

relationships = []
for edge in edges[:8]:
    source = node_label(node_by_id.get(edge.get("source"), {}))
    target = node_label(node_by_id.get(edge.get("target"), {}))
    label = (edge.get("data") or {}).get("text") or "connected to"
    relationships.append(f"- {source} -- {label} --> {target}")

print(json.dumps({
    "type": "Tree",
    "results": [
        f"# Collection Brief: {collection.get('title', 'Collection')}",
        f"Nodes: {len(nodes)}",
        f"Edges: {len(edges)}",
        {
            "Relationships": relationships or ["No internal edges found."]
        }
    ],
}))