feat(servicenow-iam): new ServiceNow IAM integration

Identity lifecycle on the sys_user table: get/create/update user
(resolved by sys_id, username or email), enable user (active=true +
locked_out cleared), disable user, and user field discovery via
sys_dictionary for mapping. Basic or OAuth 2.0 (password grant)
authentication, stdlib-only scripts.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

integrations/servicenow-cmdb/manifest.yaml

@@ -0,0 +1,145 @@
+id: servicenow_cmdb
+name: ServiceNow CMDB
+version: 1.0.0
+description: "ServiceNow CMDB (CMDB Instance API) — query configuration items by CI class, read a record with its attributes and inbound/outbound relations, create and update records with attributes and relations, and add or delete relations between CIs. Basic or OAuth 2.0 (password grant) authentication."
+changelog: "1.0.0 — Initial release: records list by class, record get by sys_id (attributes + relations), record create/update with attributes and discovery source, add/delete relations."
+category: asset_management
+
+# Per-instance configuration. The base URL is the instance root, e.g.
+# https://company.service-now.com (scripts append /api/now/cmdb/instance).
+config_schema:
+  properties:
+    url:
+      type: string
+      description: "ServiceNow instance URL, e.g. https://company.service-now.com"
+    auth_type:
+      type: string
+      description: "Authentication method: basic (username + password) or oauth (OAuth 2.0 password grant via /oauth_token.do — also requires client_id/client_secret)"
+      default: basic
+    username:
+      type: string
+      description: "ServiceNow username (needs CMDB read/write ACLs on the target CI classes)"
+    password:
+      type: string
+      description: "ServiceNow password"
+      x-soar-sensitive: true
+    client_id:
+      type: string
+      description: "OAuth client ID (oauth auth_type only — from an Application Registry entry)"
+    client_secret:
+      type: string
+      description: "OAuth client secret (oauth auth_type only)"
+      x-soar-sensitive: true
+    api_version:
+      type: string
+      description: "Optional REST API version segment (e.g. v1). Leave empty to use the unversioned endpoints."
+    test_class:
+      type: string
+      description: "CI class queried by the Test button (default cmdb_ci_computer)"
+      default: cmdb_ci_computer
+  required:
+    - url
+    - username
+    - password
+
+# Documented for reference; the bundled scripts build the headers themselves.
+# Basic:  Authorization: Basic base64(username:password)
+# OAuth:  POST /oauth_token.do (grant_type=password) then Authorization: Bearer <access_token>
+auth:
+  - id: basic
+    type: basic
+    username_field: username
+    password_field: password
+
+commands:
+  - id: records_list
+    name: servicenow-cmdb-records-list
+    description: "List the records of a CMDB CI class, optionally filtered by an encoded sysparm_query."
+    risk: read
+    inputs_schema:
+      properties:
+        class: { type: string, description: "CI class name (e.g. cmdb_ci_linux_server)" }
+        query: { type: string, description: "Encoded sysparm_query filter" }
+        limit: { type: number, description: "Maximum records per page (default 50)" }
+        offset: { type: number, description: "Starting record index (default 0)" }
+      required: [class]
+    outputs_schema: { properties: {} }
+  - id: get_record
+    name: servicenow-cmdb-get-record
+    description: "Get a CI record by sys_id: attributes plus inbound and outbound relations."
+    risk: read
+    inputs_schema:
+      properties:
+        class: { type: string, description: "CI class name of the record" }
+        sys_id: { type: string, description: "Record sys_id" }
+        fields: { type: string, description: "Comma-separated attributes to return (sys_id and name always included)" }
+        relation_limit: { type: number, description: "Maximum relations returned (default 50)" }
+        relation_offset: { type: number, description: "Starting relation index (default 0)" }
+      required: [class, sys_id]
+    outputs_schema: { properties: {} }
+  - id: create_record
+    name: servicenow-cmdb-create-record
+    description: "Create a CI record with attributes and optional inbound/outbound relations."
+    inputs_schema:
+      properties:
+        class: { type: string, description: "CI class name to create the record in" }
+        attributes: { type: string, description: "Attributes as name=value;name2=value2 (e.g. name=srv01;ram=1024)" }
+        source: { type: string, description: "Discovery source (default ServiceNow) — values live in the sys_choice table (element discovery_source, name cmdb_ci)" }
+        inbound_relations: { type: string, description: "JSON array of inbound relations, each {\"type\": \"<rel type sys_id>\", \"target\": \"<CI sys_id>\"}" }
+        outbound_relations: { type: string, description: "JSON array of outbound relations, each {\"type\": \"<rel type sys_id>\", \"target\": \"<CI sys_id>\"}" }
+        fields: { type: string, description: "Comma-separated attributes to return (sys_id and name always included)" }
+        relation_limit: { type: number, description: "Maximum relations returned (default 50)" }
+        relation_offset: { type: number, description: "Starting relation index (default 0)" }
+      required: [class, attributes]
+    outputs_schema: { properties: {} }
+  - id: update_record
+    name: servicenow-cmdb-update-record
+    description: "Update a CI record's attributes."
+    inputs_schema:
+      properties:
+        class: { type: string, description: "CI class name of the record" }
+        sys_id: { type: string, description: "Record sys_id" }
+        attributes: { type: string, description: "Attributes as name=value;name2=value2" }
+        source: { type: string, description: "Discovery source (default ServiceNow)" }
+        fields: { type: string, description: "Comma-separated attributes to return (sys_id and name always included)" }
+        relation_limit: { type: number, description: "Maximum relations returned (default 50)" }
+        relation_offset: { type: number, description: "Starting relation index (default 0)" }
+      required: [class, sys_id, attributes]
+    outputs_schema: { properties: {} }
+  - id: add_relations
+    name: servicenow-cmdb-add-relations
+    description: "Add inbound and/or outbound relations to an existing CI record."
+    inputs_schema:
+      properties:
+        class: { type: string, description: "CI class name of the record" }
+        sys_id: { type: string, description: "Record sys_id" }
+        source: { type: string, description: "Discovery source (default ServiceNow)" }
+        inbound_relations: { type: string, description: "JSON array of inbound relations, each {\"type\": \"<rel type sys_id>\", \"target\": \"<CI sys_id>\"}" }
+        outbound_relations: { type: string, description: "JSON array of outbound relations, each {\"type\": \"<rel type sys_id>\", \"target\": \"<CI sys_id>\"}" }
+        fields: { type: string, description: "Comma-separated attributes to return (sys_id and name always included)" }
+        relation_limit: { type: number, description: "Maximum relations returned (default 50)" }
+        relation_offset: { type: number, description: "Starting relation index (default 0)" }
+      required: [class, sys_id]
+    outputs_schema: { properties: {} }
+  - id: delete_relation
+    name: servicenow-cmdb-delete-relation
+    description: "Delete a relation from a CI record by the relation's sys_id."
+    inputs_schema:
+      properties:
+        class: { type: string, description: "CI class name of the record" }
+        sys_id: { type: string, description: "Record sys_id" }
+        relation_sys_id: { type: string, description: "sys_id of the relation to delete" }
+        fields: { type: string, description: "Comma-separated attributes to return (sys_id and name always included)" }
+        relation_limit: { type: number, description: "Maximum relations returned (default 50)" }
+        relation_offset: { type: number, description: "Starting relation index (default 0)" }
+      required: [class, sys_id, relation_sys_id]
+    outputs_schema: { properties: {} }
+
+  - id: test_connection
+    name: servicenow-cmdb-test-connection
+    description: "Verify connectivity and credentials (used by the Test button)."
+    risk: read
+    inputs_schema:
+      properties: {}
+      required: []
+    outputs_schema: { properties: {} }

integrations/servicenow-cmdb/scripts/add_relations.py

@@ -0,0 +1,96 @@
+import base64, json, os, sys, urllib.parse, urllib.request, urllib.error
+
+
+def _cfg():
+    return json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+
+
+def _headers(cfg):
+    h = {"Accept": "application/json", "Content-Type": "application/json"}
+    if str(cfg.get("auth_type") or "basic").lower() == "oauth":
+        data = urllib.parse.urlencode({
+            "grant_type": "password",
+            "client_id": cfg.get("client_id", ""),
+            "client_secret": cfg.get("client_secret", ""),
+            "username": cfg.get("username", ""),
+            "password": cfg.get("password", ""),
+        }).encode("utf-8")
+        req = urllib.request.Request(
+            cfg.get("url", "").rstrip("/") + "/oauth_token.do", data=data,
+            headers={"Content-Type": "application/x-www-form-urlencoded", "Accept": "application/json"}, method="POST")
+        with urllib.request.urlopen(req, timeout=60) as r:
+            tok = json.loads(r.read())
+        if not tok.get("access_token"):
+            raise Exception("OAuth token request failed: " + json.dumps(tok))
+        h["Authorization"] = "Bearer " + tok["access_token"]
+    else:
+        cred = (cfg.get("username", "") + ":" + cfg.get("password", "")).encode("utf-8")
+        h["Authorization"] = "Basic " + base64.b64encode(cred).decode("ascii")
+    return h
+
+
+def request(method, path, params=None, body=None, root="/api/now", versioned=True):
+    cfg = _cfg()
+    v = str(cfg.get("api_version") or "").strip().strip("/")
+    url = cfg.get("url", "").rstrip("/") + root + ("/" + v if v and versioned else "") + path
+    q = {k: str(x) for k, x in (params or {}).items() if x not in (None, "")}
+    if q:
+        url += "?" + urllib.parse.urlencode(q)
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=_headers(cfg), method=method)
+    with urllib.request.urlopen(req, timeout=90) as r:
+        raw = r.read()
+        return json.loads(raw) if raw else {}
+
+
+def relation_params(inputs):
+    fields = str(inputs.get("fields") or "")
+    if fields:
+        parts = [p.strip() for p in fields.split(",") if p.strip()]
+        for required in ("sys_id", "name"):
+            if required not in parts:
+                parts.append(required)
+        fields = ",".join(parts)
+    return {
+        "sysparm_fields": fields or None,
+        "sysparm_relation_limit": int(inputs.get("relation_limit") or 50),
+        "sysparm_relation_offset": int(inputs.get("relation_offset") or 0),
+    }
+
+
+def parse_relations(s):
+    if s in (None, ""):
+        return None
+    rel = json.loads(s) if isinstance(s, str) else s
+    if not isinstance(rel, list):
+        raise Exception("relations must be a JSON array of {type, target} objects")
+    return rel
+
+
+def main():
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    ci_class = str(inputs.get("class") or "")
+    sys_id = str(inputs.get("sys_id") or "")
+    if not ci_class or not sys_id:
+        raise Exception("class and sys_id are required")
+    body = {"source": str(inputs.get("source") or "ServiceNow")}
+    inbound = parse_relations(inputs.get("inbound_relations"))
+    if inbound is not None:
+        body["inbound_relations"] = inbound
+    outbound = parse_relations(inputs.get("outbound_relations"))
+    if outbound is not None:
+        body["outbound_relations"] = outbound
+    if "inbound_relations" not in body and "outbound_relations" not in body:
+        raise Exception("inbound_relations or outbound_relations is required")
+    path = "/cmdb/instance/" + urllib.parse.quote(ci_class) + "/" + urllib.parse.quote(sys_id) + "/relation"
+    print(json.dumps(request("POST", path, params=relation_params(inputs), body=body)))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/servicenow-cmdb/scripts/create_record.py

@@ -0,0 +1,111 @@
+import base64, json, os, sys, urllib.parse, urllib.request, urllib.error
+
+
+def _cfg():
+    return json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+
+
+def _headers(cfg):
+    h = {"Accept": "application/json", "Content-Type": "application/json"}
+    if str(cfg.get("auth_type") or "basic").lower() == "oauth":
+        data = urllib.parse.urlencode({
+            "grant_type": "password",
+            "client_id": cfg.get("client_id", ""),
+            "client_secret": cfg.get("client_secret", ""),
+            "username": cfg.get("username", ""),
+            "password": cfg.get("password", ""),
+        }).encode("utf-8")
+        req = urllib.request.Request(
+            cfg.get("url", "").rstrip("/") + "/oauth_token.do", data=data,
+            headers={"Content-Type": "application/x-www-form-urlencoded", "Accept": "application/json"}, method="POST")
+        with urllib.request.urlopen(req, timeout=60) as r:
+            tok = json.loads(r.read())
+        if not tok.get("access_token"):
+            raise Exception("OAuth token request failed: " + json.dumps(tok))
+        h["Authorization"] = "Bearer " + tok["access_token"]
+    else:
+        cred = (cfg.get("username", "") + ":" + cfg.get("password", "")).encode("utf-8")
+        h["Authorization"] = "Basic " + base64.b64encode(cred).decode("ascii")
+    return h
+
+
+def request(method, path, params=None, body=None, root="/api/now", versioned=True):
+    cfg = _cfg()
+    v = str(cfg.get("api_version") or "").strip().strip("/")
+    url = cfg.get("url", "").rstrip("/") + root + ("/" + v if v and versioned else "") + path
+    q = {k: str(x) for k, x in (params or {}).items() if x not in (None, "")}
+    if q:
+        url += "?" + urllib.parse.urlencode(q)
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=_headers(cfg), method=method)
+    with urllib.request.urlopen(req, timeout=90) as r:
+        raw = r.read()
+        return json.loads(raw) if raw else {}
+
+
+def relation_params(inputs):
+    fields = str(inputs.get("fields") or "")
+    if fields:
+        parts = [p.strip() for p in fields.split(",") if p.strip()]
+        for required in ("sys_id", "name"):
+            if required not in parts:
+                parts.append(required)
+        fields = ",".join(parts)
+    return {
+        "sysparm_fields": fields or None,
+        "sysparm_relation_limit": int(inputs.get("relation_limit") or 50),
+        "sysparm_relation_offset": int(inputs.get("relation_offset") or 0),
+    }
+
+
+def split_attrs(s):
+    out = {}
+    for part in str(s or "").split(";"):
+        if "=" not in part:
+            continue
+        k, v = part.split("=", 1)
+        k = k.strip()
+        if k:
+            out[k] = v
+    return out
+
+
+def parse_relations(s):
+    if s in (None, ""):
+        return None
+    rel = json.loads(s) if isinstance(s, str) else s
+    if not isinstance(rel, list):
+        raise Exception("relations must be a JSON array of {type, target} objects")
+    return rel
+
+
+def main():
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    ci_class = str(inputs.get("class") or "")
+    if not ci_class:
+        raise Exception("class is required")
+    attributes = split_attrs(inputs.get("attributes"))
+    if not attributes:
+        raise Exception("attributes is required (name=value;name2=value2)")
+    body = {
+        "attributes": attributes,
+        "source": str(inputs.get("source") or "ServiceNow"),
+    }
+    inbound = parse_relations(inputs.get("inbound_relations"))
+    if inbound is not None:
+        body["inbound_relations"] = inbound
+    outbound = parse_relations(inputs.get("outbound_relations"))
+    if outbound is not None:
+        body["outbound_relations"] = outbound
+    path = "/cmdb/instance/" + urllib.parse.quote(ci_class)
+    print(json.dumps(request("POST", path, params=relation_params(inputs), body=body)))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/servicenow-cmdb/scripts/delete_relation.py

@@ -0,0 +1,81 @@
+import base64, json, os, sys, urllib.parse, urllib.request, urllib.error
+
+
+def _cfg():
+    return json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+
+
+def _headers(cfg):
+    h = {"Accept": "application/json", "Content-Type": "application/json"}
+    if str(cfg.get("auth_type") or "basic").lower() == "oauth":
+        data = urllib.parse.urlencode({
+            "grant_type": "password",
+            "client_id": cfg.get("client_id", ""),
+            "client_secret": cfg.get("client_secret", ""),
+            "username": cfg.get("username", ""),
+            "password": cfg.get("password", ""),
+        }).encode("utf-8")
+        req = urllib.request.Request(
+            cfg.get("url", "").rstrip("/") + "/oauth_token.do", data=data,
+            headers={"Content-Type": "application/x-www-form-urlencoded", "Accept": "application/json"}, method="POST")
+        with urllib.request.urlopen(req, timeout=60) as r:
+            tok = json.loads(r.read())
+        if not tok.get("access_token"):
+            raise Exception("OAuth token request failed: " + json.dumps(tok))
+        h["Authorization"] = "Bearer " + tok["access_token"]
+    else:
+        cred = (cfg.get("username", "") + ":" + cfg.get("password", "")).encode("utf-8")
+        h["Authorization"] = "Basic " + base64.b64encode(cred).decode("ascii")
+    return h
+
+
+def request(method, path, params=None, body=None, root="/api/now", versioned=True):
+    cfg = _cfg()
+    v = str(cfg.get("api_version") or "").strip().strip("/")
+    url = cfg.get("url", "").rstrip("/") + root + ("/" + v if v and versioned else "") + path
+    q = {k: str(x) for k, x in (params or {}).items() if x not in (None, "")}
+    if q:
+        url += "?" + urllib.parse.urlencode(q)
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=_headers(cfg), method=method)
+    with urllib.request.urlopen(req, timeout=90) as r:
+        raw = r.read()
+        return json.loads(raw) if raw else {}
+
+
+def relation_params(inputs):
+    fields = str(inputs.get("fields") or "")
+    if fields:
+        parts = [p.strip() for p in fields.split(",") if p.strip()]
+        for required in ("sys_id", "name"):
+            if required not in parts:
+                parts.append(required)
+        fields = ",".join(parts)
+    return {
+        "sysparm_fields": fields or None,
+        "sysparm_relation_limit": int(inputs.get("relation_limit") or 50),
+        "sysparm_relation_offset": int(inputs.get("relation_offset") or 0),
+    }
+
+
+def main():
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    ci_class = str(inputs.get("class") or "")
+    sys_id = str(inputs.get("sys_id") or "")
+    rel_sys_id = str(inputs.get("relation_sys_id") or "")
+    if not ci_class or not sys_id or not rel_sys_id:
+        raise Exception("class, sys_id and relation_sys_id are required")
+    path = ("/cmdb/instance/" + urllib.parse.quote(ci_class) + "/" + urllib.parse.quote(sys_id)
+            + "/relation/" + urllib.parse.quote(rel_sys_id))
+    res = request("DELETE", path, params=relation_params(inputs))
+    print(json.dumps(res if res else {"ok": True, "relation_sys_id": rel_sys_id}))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/servicenow-cmdb/scripts/get_record.py

@@ -0,0 +1,78 @@
+import base64, json, os, sys, urllib.parse, urllib.request, urllib.error
+
+
+def _cfg():
+    return json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+
+
+def _headers(cfg):
+    h = {"Accept": "application/json", "Content-Type": "application/json"}
+    if str(cfg.get("auth_type") or "basic").lower() == "oauth":
+        data = urllib.parse.urlencode({
+            "grant_type": "password",
+            "client_id": cfg.get("client_id", ""),
+            "client_secret": cfg.get("client_secret", ""),
+            "username": cfg.get("username", ""),
+            "password": cfg.get("password", ""),
+        }).encode("utf-8")
+        req = urllib.request.Request(
+            cfg.get("url", "").rstrip("/") + "/oauth_token.do", data=data,
+            headers={"Content-Type": "application/x-www-form-urlencoded", "Accept": "application/json"}, method="POST")
+        with urllib.request.urlopen(req, timeout=60) as r:
+            tok = json.loads(r.read())
+        if not tok.get("access_token"):
+            raise Exception("OAuth token request failed: " + json.dumps(tok))
+        h["Authorization"] = "Bearer " + tok["access_token"]
+    else:
+        cred = (cfg.get("username", "") + ":" + cfg.get("password", "")).encode("utf-8")
+        h["Authorization"] = "Basic " + base64.b64encode(cred).decode("ascii")
+    return h
+
+
+def request(method, path, params=None, body=None, root="/api/now", versioned=True):
+    cfg = _cfg()
+    v = str(cfg.get("api_version") or "").strip().strip("/")
+    url = cfg.get("url", "").rstrip("/") + root + ("/" + v if v and versioned else "") + path
+    q = {k: str(x) for k, x in (params or {}).items() if x not in (None, "")}
+    if q:
+        url += "?" + urllib.parse.urlencode(q)
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=_headers(cfg), method=method)
+    with urllib.request.urlopen(req, timeout=90) as r:
+        raw = r.read()
+        return json.loads(raw) if raw else {}
+
+
+def relation_params(inputs):
+    fields = str(inputs.get("fields") or "")
+    if fields:
+        parts = [p.strip() for p in fields.split(",") if p.strip()]
+        for required in ("sys_id", "name"):
+            if required not in parts:
+                parts.append(required)
+        fields = ",".join(parts)
+    return {
+        "sysparm_fields": fields or None,
+        "sysparm_relation_limit": int(inputs.get("relation_limit") or 50),
+        "sysparm_relation_offset": int(inputs.get("relation_offset") or 0),
+    }
+
+
+def main():
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    ci_class = str(inputs.get("class") or "")
+    sys_id = str(inputs.get("sys_id") or "")
+    if not ci_class or not sys_id:
+        raise Exception("class and sys_id are required")
+    path = "/cmdb/instance/" + urllib.parse.quote(ci_class) + "/" + urllib.parse.quote(sys_id)
+    print(json.dumps(request("GET", path, params=relation_params(inputs))))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/servicenow-cmdb/scripts/records_list.py

@@ -0,0 +1,65 @@
+import base64, json, os, sys, urllib.parse, urllib.request, urllib.error
+
+
+def _cfg():
+    return json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+
+
+def _headers(cfg):
+    h = {"Accept": "application/json", "Content-Type": "application/json"}
+    if str(cfg.get("auth_type") or "basic").lower() == "oauth":
+        data = urllib.parse.urlencode({
+            "grant_type": "password",
+            "client_id": cfg.get("client_id", ""),
+            "client_secret": cfg.get("client_secret", ""),
+            "username": cfg.get("username", ""),
+            "password": cfg.get("password", ""),
+        }).encode("utf-8")
+        req = urllib.request.Request(
+            cfg.get("url", "").rstrip("/") + "/oauth_token.do", data=data,
+            headers={"Content-Type": "application/x-www-form-urlencoded", "Accept": "application/json"}, method="POST")
+        with urllib.request.urlopen(req, timeout=60) as r:
+            tok = json.loads(r.read())
+        if not tok.get("access_token"):
+            raise Exception("OAuth token request failed: " + json.dumps(tok))
+        h["Authorization"] = "Bearer " + tok["access_token"]
+    else:
+        cred = (cfg.get("username", "") + ":" + cfg.get("password", "")).encode("utf-8")
+        h["Authorization"] = "Basic " + base64.b64encode(cred).decode("ascii")
+    return h
+
+
+def request(method, path, params=None, body=None, root="/api/now", versioned=True):
+    cfg = _cfg()
+    v = str(cfg.get("api_version") or "").strip().strip("/")
+    url = cfg.get("url", "").rstrip("/") + root + ("/" + v if v and versioned else "") + path
+    q = {k: str(x) for k, x in (params or {}).items() if x not in (None, "")}
+    if q:
+        url += "?" + urllib.parse.urlencode(q)
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=_headers(cfg), method=method)
+    with urllib.request.urlopen(req, timeout=90) as r:
+        raw = r.read()
+        return json.loads(raw) if raw else {}
+
+
+def main():
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    ci_class = str(inputs.get("class") or "")
+    if not ci_class:
+        raise Exception("class is required")
+    print(json.dumps(request("GET", "/cmdb/instance/" + urllib.parse.quote(ci_class), params={
+        "sysparm_query": inputs.get("query"),
+        "sysparm_limit": int(inputs.get("limit") or 50),
+        "sysparm_offset": int(inputs.get("offset") or 0),
+    })))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/servicenow-cmdb/scripts/test_connection.py

@@ -0,0 +1,62 @@
+import base64, json, os, sys, urllib.parse, urllib.request, urllib.error
+
+
+def _cfg():
+    return json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+
+
+def _headers(cfg):
+    h = {"Accept": "application/json", "Content-Type": "application/json"}
+    if str(cfg.get("auth_type") or "basic").lower() == "oauth":
+        data = urllib.parse.urlencode({
+            "grant_type": "password",
+            "client_id": cfg.get("client_id", ""),
+            "client_secret": cfg.get("client_secret", ""),
+            "username": cfg.get("username", ""),
+            "password": cfg.get("password", ""),
+        }).encode("utf-8")
+        req = urllib.request.Request(
+            cfg.get("url", "").rstrip("/") + "/oauth_token.do", data=data,
+            headers={"Content-Type": "application/x-www-form-urlencoded", "Accept": "application/json"}, method="POST")
+        with urllib.request.urlopen(req, timeout=60) as r:
+            tok = json.loads(r.read())
+        if not tok.get("access_token"):
+            raise Exception("OAuth token request failed: " + json.dumps(tok))
+        h["Authorization"] = "Bearer " + tok["access_token"]
+    else:
+        cred = (cfg.get("username", "") + ":" + cfg.get("password", "")).encode("utf-8")
+        h["Authorization"] = "Basic " + base64.b64encode(cred).decode("ascii")
+    return h
+
+
+def request(method, path, params=None, body=None, root="/api/now", versioned=True):
+    cfg = _cfg()
+    v = str(cfg.get("api_version") or "").strip().strip("/")
+    url = cfg.get("url", "").rstrip("/") + root + ("/" + v if v and versioned else "") + path
+    q = {k: str(x) for k, x in (params or {}).items() if x not in (None, "")}
+    if q:
+        url += "?" + urllib.parse.urlencode(q)
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=_headers(cfg), method=method)
+    with urllib.request.urlopen(req, timeout=90) as r:
+        raw = r.read()
+        return json.loads(raw) if raw else {}
+
+
+def main():
+    cfg = _cfg()
+    ci_class = str(cfg.get("test_class") or "cmdb_ci_computer")
+    res = request("GET", "/cmdb/instance/" + urllib.parse.quote(ci_class), params={"sysparm_limit": 1})
+    if "result" not in res:
+        raise Exception("Unexpected response: " + json.dumps(res))
+    print(json.dumps({"ok": True, "class": ci_class}))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/servicenow-cmdb/scripts/update_record.py

@@ -0,0 +1,97 @@
+import base64, json, os, sys, urllib.parse, urllib.request, urllib.error
+
+
+def _cfg():
+    return json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+
+
+def _headers(cfg):
+    h = {"Accept": "application/json", "Content-Type": "application/json"}
+    if str(cfg.get("auth_type") or "basic").lower() == "oauth":
+        data = urllib.parse.urlencode({
+            "grant_type": "password",
+            "client_id": cfg.get("client_id", ""),
+            "client_secret": cfg.get("client_secret", ""),
+            "username": cfg.get("username", ""),
+            "password": cfg.get("password", ""),
+        }).encode("utf-8")
+        req = urllib.request.Request(
+            cfg.get("url", "").rstrip("/") + "/oauth_token.do", data=data,
+            headers={"Content-Type": "application/x-www-form-urlencoded", "Accept": "application/json"}, method="POST")
+        with urllib.request.urlopen(req, timeout=60) as r:
+            tok = json.loads(r.read())
+        if not tok.get("access_token"):
+            raise Exception("OAuth token request failed: " + json.dumps(tok))
+        h["Authorization"] = "Bearer " + tok["access_token"]
+    else:
+        cred = (cfg.get("username", "") + ":" + cfg.get("password", "")).encode("utf-8")
+        h["Authorization"] = "Basic " + base64.b64encode(cred).decode("ascii")
+    return h
+
+
+def request(method, path, params=None, body=None, root="/api/now", versioned=True):
+    cfg = _cfg()
+    v = str(cfg.get("api_version") or "").strip().strip("/")
+    url = cfg.get("url", "").rstrip("/") + root + ("/" + v if v and versioned else "") + path
+    q = {k: str(x) for k, x in (params or {}).items() if x not in (None, "")}
+    if q:
+        url += "?" + urllib.parse.urlencode(q)
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=_headers(cfg), method=method)
+    with urllib.request.urlopen(req, timeout=90) as r:
+        raw = r.read()
+        return json.loads(raw) if raw else {}
+
+
+def relation_params(inputs):
+    fields = str(inputs.get("fields") or "")
+    if fields:
+        parts = [p.strip() for p in fields.split(",") if p.strip()]
+        for required in ("sys_id", "name"):
+            if required not in parts:
+                parts.append(required)
+        fields = ",".join(parts)
+    return {
+        "sysparm_fields": fields or None,
+        "sysparm_relation_limit": int(inputs.get("relation_limit") or 50),
+        "sysparm_relation_offset": int(inputs.get("relation_offset") or 0),
+    }
+
+
+def split_attrs(s):
+    out = {}
+    for part in str(s or "").split(";"):
+        if "=" not in part:
+            continue
+        k, v = part.split("=", 1)
+        k = k.strip()
+        if k:
+            out[k] = v
+    return out
+
+
+def main():
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    ci_class = str(inputs.get("class") or "")
+    sys_id = str(inputs.get("sys_id") or "")
+    if not ci_class or not sys_id:
+        raise Exception("class and sys_id are required")
+    attributes = split_attrs(inputs.get("attributes"))
+    if not attributes:
+        raise Exception("attributes is required (name=value;name2=value2)")
+    body = {
+        "attributes": attributes,
+        "source": str(inputs.get("source") or "ServiceNow"),
+    }
+    path = "/cmdb/instance/" + urllib.parse.quote(ci_class) + "/" + urllib.parse.quote(sys_id)
+    print(json.dumps(request("PATCH", path, params=relation_params(inputs), body=body)))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/servicenow-iam/manifest.yaml

@@ -0,0 +1,140 @@
+id: servicenow_iam
+name: ServiceNow IAM
+version: 1.0.0
+description: "ServiceNow identity lifecycle (sys_user table) — look up, create and update employee accounts, enable/disable accounts (with lock-out clearing), and discover the available user fields for mapping. Basic or OAuth 2.0 (password grant) authentication."
+changelog: "1.0.0 — Initial release: get/create/update user, enable/disable user, user field discovery via sys_dictionary."
+category: identity
+
+# Per-instance configuration. The base URL is the instance root, e.g.
+# https://company.service-now.com (scripts append /api/now).
+config_schema:
+  properties:
+    url:
+      type: string
+      description: "ServiceNow instance URL, e.g. https://company.service-now.com"
+    auth_type:
+      type: string
+      description: "Authentication method: basic (username + password) or oauth (OAuth 2.0 password grant via /oauth_token.do — also requires client_id/client_secret)"
+      default: basic
+    username:
+      type: string
+      description: "ServiceNow username (needs read/write ACLs on the sys_user table)"
+    password:
+      type: string
+      description: "ServiceNow password"
+      x-soar-sensitive: true
+    client_id:
+      type: string
+      description: "OAuth client ID (oauth auth_type only — from an Application Registry entry)"
+    client_secret:
+      type: string
+      description: "OAuth client secret (oauth auth_type only)"
+      x-soar-sensitive: true
+    api_version:
+      type: string
+      description: "Optional REST API version segment (e.g. v2). Leave empty to use the unversioned endpoints."
+  required:
+    - url
+    - username
+    - password
+
+# Documented for reference; the bundled scripts build the headers themselves.
+# Basic:  Authorization: Basic base64(username:password)
+# OAuth:  POST /oauth_token.do (grant_type=password) then Authorization: Bearer <access_token>
+auth:
+  - id: basic
+    type: basic
+    username_field: username
+    password_field: password
+
+# User resolution: every account command accepts user_id (sys_id), user_name or
+# email — the first one provided wins, in that order.
+commands:
+  - id: get_user
+    name: servicenow-iam-get-user
+    description: "Look up a user account by sys_id, username or email."
+    risk: read
+    inputs_schema:
+      properties:
+        user_id: { type: string, description: "User sys_id" }
+        user_name: { type: string, description: "Username (user_name field)" }
+        email: { type: string, description: "Email address" }
+        fields: { type: string, description: "Comma-separated fields to return (sys_id always included)" }
+      required: []
+    outputs_schema: { properties: {} }
+  - id: create_user
+    name: servicenow-iam-create-user
+    description: "Create a user account. Common fields have named inputs; anything else goes through fields/custom_fields."
+    inputs_schema:
+      properties:
+        user_name: { type: string, description: "Username (user_name field)" }
+        email: { type: string, description: "Email address" }
+        first_name: { type: string, description: "First name" }
+        last_name: { type: string, description: "Last name" }
+        title: { type: string, description: "Job title" }
+        department: { type: string, description: "Department (sys_id or exact name)" }
+        manager: { type: string, description: "Manager (sys_id or exact user name)" }
+        phone: { type: string, description: "Business phone" }
+        mobile_phone: { type: string, description: "Mobile phone" }
+        active: { type: boolean, description: "Account active state (default true)" }
+        fields: { type: string, description: "Additional sys_user fields as name=value;name2=value2" }
+        custom_fields: { type: string, description: "Custom fields as name=value;name2=value2 (u_ prefix added when missing)" }
+      required: [user_name]
+    outputs_schema: { properties: {} }
+  - id: update_user
+    name: servicenow-iam-update-user
+    description: "Update a user account resolved by sys_id, username or email."
+    inputs_schema:
+      properties:
+        user_id: { type: string, description: "User sys_id" }
+        user_name: { type: string, description: "Username used to resolve the account when user_id is empty" }
+        email: { type: string, description: "Email used to resolve the account when user_id and user_name are empty" }
+        first_name: { type: string, description: "First name" }
+        last_name: { type: string, description: "Last name" }
+        title: { type: string, description: "Job title" }
+        department: { type: string, description: "Department (sys_id or exact name)" }
+        manager: { type: string, description: "Manager (sys_id or exact user name)" }
+        phone: { type: string, description: "Business phone" }
+        mobile_phone: { type: string, description: "Mobile phone" }
+        fields: { type: string, description: "Additional sys_user fields as name=value;name2=value2" }
+        custom_fields: { type: string, description: "Custom fields as name=value;name2=value2 (u_ prefix added when missing)" }
+      required: []
+    outputs_schema: { properties: {} }
+  - id: enable_user
+    name: servicenow-iam-enable-user
+    description: "Enable a user account (sets active=true and clears locked_out), resolved by sys_id, username or email."
+    inputs_schema:
+      properties:
+        user_id: { type: string, description: "User sys_id" }
+        user_name: { type: string, description: "Username used to resolve the account when user_id is empty" }
+        email: { type: string, description: "Email used to resolve the account when user_id and user_name are empty" }
+      required: []
+    outputs_schema: { properties: {} }
+  - id: disable_user
+    name: servicenow-iam-disable-user
+    description: "Disable a user account (sets active=false), resolved by sys_id, username or email."
+    inputs_schema:
+      properties:
+        user_id: { type: string, description: "User sys_id" }
+        user_name: { type: string, description: "Username used to resolve the account when user_id is empty" }
+        email: { type: string, description: "Email used to resolve the account when user_id and user_name are empty" }
+      required: []
+    outputs_schema: { properties: {} }
+  - id: list_user_fields
+    name: servicenow-iam-list-user-fields
+    description: "List the sys_user table fields (name and label) from the sys_dictionary — useful to build field mappings."
+    risk: read
+    inputs_schema:
+      properties:
+        limit: { type: number, description: "Maximum dictionary entries (default 500)" }
+      required: []
+    outputs_schema: { properties: {} }
+
+  - id: test_connection
+    name: servicenow-iam-test-connection
+    description: "Verify connectivity and credentials (used by the Test button)."
+    risk: read
+    inputs_schema:
+      properties: {}
+      required: []
+    outputs_schema: { properties: {} }

integrations/servicenow-iam/scripts/create_user.py

@@ -0,0 +1,88 @@
+import base64, json, os, sys, urllib.parse, urllib.request, urllib.error
+
+
+def _cfg():
+    return json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+
+
+def _headers(cfg):
+    h = {"Accept": "application/json", "Content-Type": "application/json"}
+    if str(cfg.get("auth_type") or "basic").lower() == "oauth":
+        data = urllib.parse.urlencode({
+            "grant_type": "password",
+            "client_id": cfg.get("client_id", ""),
+            "client_secret": cfg.get("client_secret", ""),
+            "username": cfg.get("username", ""),
+            "password": cfg.get("password", ""),
+        }).encode("utf-8")
+        req = urllib.request.Request(
+            cfg.get("url", "").rstrip("/") + "/oauth_token.do", data=data,
+            headers={"Content-Type": "application/x-www-form-urlencoded", "Accept": "application/json"}, method="POST")
+        with urllib.request.urlopen(req, timeout=60) as r:
+            tok = json.loads(r.read())
+        if not tok.get("access_token"):
+            raise Exception("OAuth token request failed: " + json.dumps(tok))
+        h["Authorization"] = "Bearer " + tok["access_token"]
+    else:
+        cred = (cfg.get("username", "") + ":" + cfg.get("password", "")).encode("utf-8")
+        h["Authorization"] = "Basic " + base64.b64encode(cred).decode("ascii")
+    return h
+
+
+def request(method, path, params=None, body=None, root="/api/now", versioned=True):
+    cfg = _cfg()
+    v = str(cfg.get("api_version") or "").strip().strip("/")
+    url = cfg.get("url", "").rstrip("/") + root + ("/" + v if v and versioned else "") + path
+    q = {k: str(x) for k, x in (params or {}).items() if x not in (None, "")}
+    if q:
+        url += "?" + urllib.parse.urlencode(q)
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=_headers(cfg), method=method)
+    with urllib.request.urlopen(req, timeout=90) as r:
+        raw = r.read()
+        return json.loads(raw) if raw else {}
+
+
+def split_fields(s, prefix_custom=False):
+    out = {}
+    for part in str(s or "").split(";"):
+        if "=" not in part:
+            continue
+        k, v = part.split("=", 1)
+        k = k.strip()
+        if prefix_custom and k and not k.startswith("u_"):
+            k = "u_" + k
+        if k:
+            out[k] = v
+    return out
+
+
+NAMED_FIELDS = [
+    "user_name", "email", "first_name", "last_name", "title",
+    "department", "manager", "phone", "mobile_phone",
+]
+
+
+def main():
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    if not str(inputs.get("user_name") or ""):
+        raise Exception("user_name is required")
+    body = {}
+    for k in NAMED_FIELDS:
+        v = inputs.get(k)
+        if v not in (None, ""):
+            body[k] = v
+    body["active"] = bool(inputs.get("active", True))
+    body.update(split_fields(inputs.get("fields")))
+    body.update(split_fields(inputs.get("custom_fields"), prefix_custom=True))
+    print(json.dumps(request("POST", "/table/sys_user", body=body)))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/servicenow-iam/scripts/disable_user.py

@@ -0,0 +1,79 @@
+import base64, json, os, sys, urllib.parse, urllib.request, urllib.error
+
+
+def _cfg():
+    return json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+
+
+def _headers(cfg):
+    h = {"Accept": "application/json", "Content-Type": "application/json"}
+    if str(cfg.get("auth_type") or "basic").lower() == "oauth":
+        data = urllib.parse.urlencode({
+            "grant_type": "password",
+            "client_id": cfg.get("client_id", ""),
+            "client_secret": cfg.get("client_secret", ""),
+            "username": cfg.get("username", ""),
+            "password": cfg.get("password", ""),
+        }).encode("utf-8")
+        req = urllib.request.Request(
+            cfg.get("url", "").rstrip("/") + "/oauth_token.do", data=data,
+            headers={"Content-Type": "application/x-www-form-urlencoded", "Accept": "application/json"}, method="POST")
+        with urllib.request.urlopen(req, timeout=60) as r:
+            tok = json.loads(r.read())
+        if not tok.get("access_token"):
+            raise Exception("OAuth token request failed: " + json.dumps(tok))
+        h["Authorization"] = "Bearer " + tok["access_token"]
+    else:
+        cred = (cfg.get("username", "") + ":" + cfg.get("password", "")).encode("utf-8")
+        h["Authorization"] = "Basic " + base64.b64encode(cred).decode("ascii")
+    return h
+
+
+def request(method, path, params=None, body=None, root="/api/now", versioned=True):
+    cfg = _cfg()
+    v = str(cfg.get("api_version") or "").strip().strip("/")
+    url = cfg.get("url", "").rstrip("/") + root + ("/" + v if v and versioned else "") + path
+    q = {k: str(x) for k, x in (params or {}).items() if x not in (None, "")}
+    if q:
+        url += "?" + urllib.parse.urlencode(q)
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=_headers(cfg), method=method)
+    with urllib.request.urlopen(req, timeout=90) as r:
+        raw = r.read()
+        return json.loads(raw) if raw else {}
+
+
+def find_user_sys_id(inputs):
+    uid = str(inputs.get("user_id") or "")
+    if uid:
+        return uid
+    for key in ("user_name", "email"):
+        val = str(inputs.get(key) or "")
+        if val:
+            res = request("GET", "/table/sys_user", params={
+                "sysparm_query": key + "=" + val,
+                "sysparm_limit": 1,
+                "sysparm_fields": "sys_id",
+            })
+            rows = res.get("result") or []
+            if not rows:
+                raise Exception("user not found (" + key + "=" + val + ")")
+            return rows[0]["sys_id"]
+    raise Exception("user_id, user_name or email is required")
+
+
+def main():
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    sys_id = find_user_sys_id(inputs)
+    body = {"active": False}
+    print(json.dumps(request("PATCH", "/table/sys_user/" + urllib.parse.quote(sys_id), body=body)))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/servicenow-iam/scripts/enable_user.py

@@ -0,0 +1,79 @@
+import base64, json, os, sys, urllib.parse, urllib.request, urllib.error
+
+
+def _cfg():
+    return json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+
+
+def _headers(cfg):
+    h = {"Accept": "application/json", "Content-Type": "application/json"}
+    if str(cfg.get("auth_type") or "basic").lower() == "oauth":
+        data = urllib.parse.urlencode({
+            "grant_type": "password",
+            "client_id": cfg.get("client_id", ""),
+            "client_secret": cfg.get("client_secret", ""),
+            "username": cfg.get("username", ""),
+            "password": cfg.get("password", ""),
+        }).encode("utf-8")
+        req = urllib.request.Request(
+            cfg.get("url", "").rstrip("/") + "/oauth_token.do", data=data,
+            headers={"Content-Type": "application/x-www-form-urlencoded", "Accept": "application/json"}, method="POST")
+        with urllib.request.urlopen(req, timeout=60) as r:
+            tok = json.loads(r.read())
+        if not tok.get("access_token"):
+            raise Exception("OAuth token request failed: " + json.dumps(tok))
+        h["Authorization"] = "Bearer " + tok["access_token"]
+    else:
+        cred = (cfg.get("username", "") + ":" + cfg.get("password", "")).encode("utf-8")
+        h["Authorization"] = "Basic " + base64.b64encode(cred).decode("ascii")
+    return h
+
+
+def request(method, path, params=None, body=None, root="/api/now", versioned=True):
+    cfg = _cfg()
+    v = str(cfg.get("api_version") or "").strip().strip("/")
+    url = cfg.get("url", "").rstrip("/") + root + ("/" + v if v and versioned else "") + path
+    q = {k: str(x) for k, x in (params or {}).items() if x not in (None, "")}
+    if q:
+        url += "?" + urllib.parse.urlencode(q)
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=_headers(cfg), method=method)
+    with urllib.request.urlopen(req, timeout=90) as r:
+        raw = r.read()
+        return json.loads(raw) if raw else {}
+
+
+def find_user_sys_id(inputs):
+    uid = str(inputs.get("user_id") or "")
+    if uid:
+        return uid
+    for key in ("user_name", "email"):
+        val = str(inputs.get(key) or "")
+        if val:
+            res = request("GET", "/table/sys_user", params={
+                "sysparm_query": key + "=" + val,
+                "sysparm_limit": 1,
+                "sysparm_fields": "sys_id",
+            })
+            rows = res.get("result") or []
+            if not rows:
+                raise Exception("user not found (" + key + "=" + val + ")")
+            return rows[0]["sys_id"]
+    raise Exception("user_id, user_name or email is required")
+
+
+def main():
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    sys_id = find_user_sys_id(inputs)
+    body = {"active": True, "locked_out": False}
+    print(json.dumps(request("PATCH", "/table/sys_user/" + urllib.parse.quote(sys_id), body=body)))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/servicenow-iam/scripts/get_user.py

@@ -0,0 +1,74 @@
+import base64, json, os, sys, urllib.parse, urllib.request, urllib.error
+
+
+def _cfg():
+    return json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+
+
+def _headers(cfg):
+    h = {"Accept": "application/json", "Content-Type": "application/json"}
+    if str(cfg.get("auth_type") or "basic").lower() == "oauth":
+        data = urllib.parse.urlencode({
+            "grant_type": "password",
+            "client_id": cfg.get("client_id", ""),
+            "client_secret": cfg.get("client_secret", ""),
+            "username": cfg.get("username", ""),
+            "password": cfg.get("password", ""),
+        }).encode("utf-8")
+        req = urllib.request.Request(
+            cfg.get("url", "").rstrip("/") + "/oauth_token.do", data=data,
+            headers={"Content-Type": "application/x-www-form-urlencoded", "Accept": "application/json"}, method="POST")
+        with urllib.request.urlopen(req, timeout=60) as r:
+            tok = json.loads(r.read())
+        if not tok.get("access_token"):
+            raise Exception("OAuth token request failed: " + json.dumps(tok))
+        h["Authorization"] = "Bearer " + tok["access_token"]
+    else:
+        cred = (cfg.get("username", "") + ":" + cfg.get("password", "")).encode("utf-8")
+        h["Authorization"] = "Basic " + base64.b64encode(cred).decode("ascii")
+    return h
+
+
+def request(method, path, params=None, body=None, root="/api/now", versioned=True):
+    cfg = _cfg()
+    v = str(cfg.get("api_version") or "").strip().strip("/")
+    url = cfg.get("url", "").rstrip("/") + root + ("/" + v if v and versioned else "") + path
+    q = {k: str(x) for k, x in (params or {}).items() if x not in (None, "")}
+    if q:
+        url += "?" + urllib.parse.urlencode(q)
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=_headers(cfg), method=method)
+    with urllib.request.urlopen(req, timeout=90) as r:
+        raw = r.read()
+        return json.loads(raw) if raw else {}
+
+
+def main():
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    fields = str(inputs.get("fields") or "")
+    if fields and "sys_id" not in [p.strip() for p in fields.split(",")]:
+        fields += ",sys_id"
+    params = {"sysparm_fields": fields or None}
+
+    uid = str(inputs.get("user_id") or "")
+    if uid:
+        print(json.dumps(request("GET", "/table/sys_user/" + urllib.parse.quote(uid), params=params)))
+        return
+    for key in ("user_name", "email"):
+        val = str(inputs.get(key) or "")
+        if val:
+            params["sysparm_query"] = key + "=" + val
+            params["sysparm_limit"] = 1
+            print(json.dumps(request("GET", "/table/sys_user", params=params)))
+            return
+    raise Exception("user_id, user_name or email is required")
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/servicenow-iam/scripts/list_user_fields.py

@@ -0,0 +1,69 @@
+import base64, json, os, sys, urllib.parse, urllib.request, urllib.error
+
+
+def _cfg():
+    return json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+
+
+def _headers(cfg):
+    h = {"Accept": "application/json", "Content-Type": "application/json"}
+    if str(cfg.get("auth_type") or "basic").lower() == "oauth":
+        data = urllib.parse.urlencode({
+            "grant_type": "password",
+            "client_id": cfg.get("client_id", ""),
+            "client_secret": cfg.get("client_secret", ""),
+            "username": cfg.get("username", ""),
+            "password": cfg.get("password", ""),
+        }).encode("utf-8")
+        req = urllib.request.Request(
+            cfg.get("url", "").rstrip("/") + "/oauth_token.do", data=data,
+            headers={"Content-Type": "application/x-www-form-urlencoded", "Accept": "application/json"}, method="POST")
+        with urllib.request.urlopen(req, timeout=60) as r:
+            tok = json.loads(r.read())
+        if not tok.get("access_token"):
+            raise Exception("OAuth token request failed: " + json.dumps(tok))
+        h["Authorization"] = "Bearer " + tok["access_token"]
+    else:
+        cred = (cfg.get("username", "") + ":" + cfg.get("password", "")).encode("utf-8")
+        h["Authorization"] = "Basic " + base64.b64encode(cred).decode("ascii")
+    return h
+
+
+def request(method, path, params=None, body=None, root="/api/now", versioned=True):
+    cfg = _cfg()
+    v = str(cfg.get("api_version") or "").strip().strip("/")
+    url = cfg.get("url", "").rstrip("/") + root + ("/" + v if v and versioned else "") + path
+    q = {k: str(x) for k, x in (params or {}).items() if x not in (None, "")}
+    if q:
+        url += "?" + urllib.parse.urlencode(q)
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=_headers(cfg), method=method)
+    with urllib.request.urlopen(req, timeout=90) as r:
+        raw = r.read()
+        return json.loads(raw) if raw else {}
+
+
+def main():
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    res = request("GET", "/table/sys_dictionary", params={
+        "sysparm_query": "name=sys_user",
+        "sysparm_fields": "element,sys_name,internal_type",
+        "sysparm_limit": int(inputs.get("limit") or 500),
+    })
+    fields = []
+    for row in res.get("result") or []:
+        name = row.get("element")
+        if name:
+            fields.append({"name": name, "label": row.get("sys_name"), "type": row.get("internal_type")})
+    fields.sort(key=lambda f: f["name"])
+    print(json.dumps({"table": "sys_user", "fields": fields}))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/servicenow-iam/scripts/test_connection.py

@@ -0,0 +1,60 @@
+import base64, json, os, sys, urllib.parse, urllib.request, urllib.error
+
+
+def _cfg():
+    return json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+
+
+def _headers(cfg):
+    h = {"Accept": "application/json", "Content-Type": "application/json"}
+    if str(cfg.get("auth_type") or "basic").lower() == "oauth":
+        data = urllib.parse.urlencode({
+            "grant_type": "password",
+            "client_id": cfg.get("client_id", ""),
+            "client_secret": cfg.get("client_secret", ""),
+            "username": cfg.get("username", ""),
+            "password": cfg.get("password", ""),
+        }).encode("utf-8")
+        req = urllib.request.Request(
+            cfg.get("url", "").rstrip("/") + "/oauth_token.do", data=data,
+            headers={"Content-Type": "application/x-www-form-urlencoded", "Accept": "application/json"}, method="POST")
+        with urllib.request.urlopen(req, timeout=60) as r:
+            tok = json.loads(r.read())
+        if not tok.get("access_token"):
+            raise Exception("OAuth token request failed: " + json.dumps(tok))
+        h["Authorization"] = "Bearer " + tok["access_token"]
+    else:
+        cred = (cfg.get("username", "") + ":" + cfg.get("password", "")).encode("utf-8")
+        h["Authorization"] = "Basic " + base64.b64encode(cred).decode("ascii")
+    return h
+
+
+def request(method, path, params=None, body=None, root="/api/now", versioned=True):
+    cfg = _cfg()
+    v = str(cfg.get("api_version") or "").strip().strip("/")
+    url = cfg.get("url", "").rstrip("/") + root + ("/" + v if v and versioned else "") + path
+    q = {k: str(x) for k, x in (params or {}).items() if x not in (None, "")}
+    if q:
+        url += "?" + urllib.parse.urlencode(q)
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=_headers(cfg), method=method)
+    with urllib.request.urlopen(req, timeout=90) as r:
+        raw = r.read()
+        return json.loads(raw) if raw else {}
+
+
+def main():
+    res = request("GET", "/table/sys_user", params={"sysparm_limit": 1})
+    if "result" not in res:
+        raise Exception("Unexpected response: " + json.dumps(res))
+    print(json.dumps({"ok": True, "table": "sys_user"}))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/servicenow-iam/scripts/update_user.py

@@ -0,0 +1,107 @@
+import base64, json, os, sys, urllib.parse, urllib.request, urllib.error
+
+
+def _cfg():
+    return json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+
+
+def _headers(cfg):
+    h = {"Accept": "application/json", "Content-Type": "application/json"}
+    if str(cfg.get("auth_type") or "basic").lower() == "oauth":
+        data = urllib.parse.urlencode({
+            "grant_type": "password",
+            "client_id": cfg.get("client_id", ""),
+            "client_secret": cfg.get("client_secret", ""),
+            "username": cfg.get("username", ""),
+            "password": cfg.get("password", ""),
+        }).encode("utf-8")
+        req = urllib.request.Request(
+            cfg.get("url", "").rstrip("/") + "/oauth_token.do", data=data,
+            headers={"Content-Type": "application/x-www-form-urlencoded", "Accept": "application/json"}, method="POST")
+        with urllib.request.urlopen(req, timeout=60) as r:
+            tok = json.loads(r.read())
+        if not tok.get("access_token"):
+            raise Exception("OAuth token request failed: " + json.dumps(tok))
+        h["Authorization"] = "Bearer " + tok["access_token"]
+    else:
+        cred = (cfg.get("username", "") + ":" + cfg.get("password", "")).encode("utf-8")
+        h["Authorization"] = "Basic " + base64.b64encode(cred).decode("ascii")
+    return h
+
+
+def request(method, path, params=None, body=None, root="/api/now", versioned=True):
+    cfg = _cfg()
+    v = str(cfg.get("api_version") or "").strip().strip("/")
+    url = cfg.get("url", "").rstrip("/") + root + ("/" + v if v and versioned else "") + path
+    q = {k: str(x) for k, x in (params or {}).items() if x not in (None, "")}
+    if q:
+        url += "?" + urllib.parse.urlencode(q)
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=_headers(cfg), method=method)
+    with urllib.request.urlopen(req, timeout=90) as r:
+        raw = r.read()
+        return json.loads(raw) if raw else {}
+
+
+def find_user_sys_id(inputs):
+    uid = str(inputs.get("user_id") or "")
+    if uid:
+        return uid
+    for key in ("user_name", "email"):
+        val = str(inputs.get(key) or "")
+        if val:
+            res = request("GET", "/table/sys_user", params={
+                "sysparm_query": key + "=" + val,
+                "sysparm_limit": 1,
+                "sysparm_fields": "sys_id",
+            })
+            rows = res.get("result") or []
+            if not rows:
+                raise Exception("user not found (" + key + "=" + val + ")")
+            return rows[0]["sys_id"]
+    raise Exception("user_id, user_name or email is required")
+
+
+def split_fields(s, prefix_custom=False):
+    out = {}
+    for part in str(s or "").split(";"):
+        if "=" not in part:
+            continue
+        k, v = part.split("=", 1)
+        k = k.strip()
+        if prefix_custom and k and not k.startswith("u_"):
+            k = "u_" + k
+        if k:
+            out[k] = v
+    return out
+
+
+NAMED_FIELDS = [
+    "first_name", "last_name", "title",
+    "department", "manager", "phone", "mobile_phone",
+]
+
+
+def main():
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    sys_id = find_user_sys_id(inputs)
+    body = {}
+    for k in NAMED_FIELDS:
+        v = inputs.get(k)
+        if v not in (None, ""):
+            body[k] = v
+    body.update(split_fields(inputs.get("fields")))
+    body.update(split_fields(inputs.get("custom_fields"), prefix_custom=True))
+    if not body:
+        raise Exception("nothing to update")
+    print(json.dumps(request("PATCH", "/table/sys_user/" + urllib.parse.quote(sys_id), body=body)))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/servicenow/incident-types/servicenow-ticket.yaml

@@ -0,0 +1,3 @@
+name: "ServiceNow Ticket"
+color: "#81b5a1"
+icon: "alert"

integrations/servicenow/manifest.yaml

@@ -0,0 +1,446 @@
+id: servicenow
+name: ServiceNow
+version: 1.0.0
+description: "ServiceNow ITSM (Table / Service Catalog / Change Management REST APIs) — ticket lifecycle (create/update/resolve/delete, comments, work notes, links, tags, journal notes), generic table records CRUD, CMDB and user/group queries, service catalog ordering, standard change creation, attachments, work-item queue routing, plus ticket ingestion (get_incidents) with an OCSF mapper. Basic or OAuth 2.0 (password grant) authentication."
+changelog: "1.0.0 — Initial release: ticket lifecycle commands (incident, problem, change_request, sc_request, sc_task, sc_req_item), records/table CRUD and discovery, CMDB computer/group/user queries, service catalog (search, details, order), standard change from template + change tasks, attachments (list/upload/delete), queue routing, generic API call, and ticket ingestion with a bundled OCSF mapper."
+category: ticketing
+
+# Per-instance configuration. The base URL is the instance root, e.g.
+# https://company.service-now.com (scripts append /api/now, /api/sn_sc, /api/sn_chg_rest).
+config_schema:
+  properties:
+    url:
+      type: string
+      description: "ServiceNow instance URL, e.g. https://company.service-now.com"
+    auth_type:
+      type: string
+      description: "Authentication method: basic (username + password) or oauth (OAuth 2.0 password grant via /oauth_token.do — also requires client_id/client_secret)"
+      default: basic
+    username:
+      type: string
+      description: "ServiceNow username (needs rest_api_explorer/web_service_admin style roles plus read/write ACLs on the target tables)"
+    password:
+      type: string
+      description: "ServiceNow password"
+      x-soar-sensitive: true
+    client_id:
+      type: string
+      description: "OAuth client ID (oauth auth_type only — from an Application Registry entry)"
+    client_secret:
+      type: string
+      description: "OAuth client secret (oauth auth_type only)"
+      x-soar-sensitive: true
+    api_version:
+      type: string
+      description: "Optional REST API version segment (e.g. v2). Leave empty to use the unversioned endpoints."
+    ticket_type:
+      type: string
+      description: "Default ticket table for ticket commands and ingestion: incident, problem, change_request, sc_request, sc_task or sc_req_item"
+      default: incident
+    timestamp_field:
+      type: string
+      description: "Timestamp field used as the ingestion watermark (e.g. opened_at or sys_created_on)"
+      default: opened_at
+  required:
+    - url
+    - username
+    - password
+
+# Documented for reference; the bundled scripts build the headers themselves.
+# Basic:  Authorization: Basic base64(username:password)
+# OAuth:  POST /oauth_token.do (grant_type=password) then Authorization: Bearer <access_token>
+auth:
+  - id: basic
+    type: basic
+    username_field: username
+    password_field: password
+
+commands:
+  # ── Ingestion ─────────────────────────────────────────────────────────────
+  - id: get_incidents
+    name: servicenow-get-incidents
+    description: "Fetch tickets from the configured ticket table for ingestion. Returns {result:[...]}; use result as the alert rule results path."
+    risk: read
+    inputs_schema:
+      properties:
+        query: { type: string, description: "Extra sysparm_query filter prepended to the watermark clause (e.g. stateNOT IN6,7)" }
+        created_after: { type: string, description: "Lower bound on the configured timestamp field, ISO8601, epoch ms or 'YYYY-MM-DD HH:MM:SS' (incremental fetch watermark)" }
+        ticket_type: { type: string, description: "Override the configured ticket table" }
+        limit: { type: number, description: "Maximum tickets to fetch (default 100)" }
+      required: []
+    outputs_schema: { properties: {} }
+    ingest:
+      results_path: result
+      dedup_key: sys_id
+      incremental_field: created_after
+
+  # ── Tickets ───────────────────────────────────────────────────────────────
+  - id: get_ticket
+    name: servicenow-get-ticket
+    description: "Retrieve a ticket by sys_id or number from any ticket table."
+    risk: read
+    inputs_schema:
+      properties:
+        id: { type: string, description: "Ticket sys_id" }
+        number: { type: string, description: "Ticket number (e.g. INC0010001) — used when id is empty" }
+        ticket_type: { type: string, description: "Ticket table: incident, problem, change_request, sc_request, sc_task, sc_req_item (default from instance config)" }
+        fields: { type: string, description: "Comma-separated list of fields to return (sys_id always included)" }
+        display_value: { type: string, description: "sysparm_display_value: true, false or all (default false)" }
+      required: []
+    outputs_schema: { properties: {} }
+  - id: create_ticket
+    name: servicenow-create-ticket
+    description: "Create a ticket. Common fields have named inputs; anything else goes through fields/custom_fields."
+    inputs_schema:
+      properties:
+        ticket_type: { type: string, description: "Ticket table (default from instance config)" }
+        short_description: { type: string, description: "Short description (title)" }
+        description: { type: string, description: "Full description" }
+        urgency: { type: string, description: "Urgency (1, 2 or 3)" }
+        impact: { type: string, description: "Impact (1, 2 or 3)" }
+        priority: { type: string, description: "Priority (1-Critical … 5-Planning)" }
+        state: { type: string, description: "State code (numeric, table-specific)" }
+        category: { type: string, description: "Category" }
+        subcategory: { type: string, description: "Subcategory" }
+        caller_id: { type: string, description: "Caller (sys_id or exact user name)" }
+        assigned_to: { type: string, description: "Assignee (sys_id or exact user name)" }
+        assignment_group: { type: string, description: "Assignment group (sys_id or exact group name)" }
+        comments: { type: string, description: "Customer-visible comment to add on creation" }
+        work_notes: { type: string, description: "Internal work note to add on creation" }
+        fields: { type: string, description: "Additional fields as name=value;name2=value2" }
+        custom_fields: { type: string, description: "Custom fields as name=value;name2=value2 (u_ prefix added when missing)" }
+        input_display_value: { type: boolean, description: "Treat input values as display values (sysparm_input_display_value)" }
+      required: []
+    outputs_schema: { properties: {} }
+  - id: update_ticket
+    name: servicenow-update-ticket
+    description: "Update a ticket by sys_id (state changes, reassignment, resolution fields, any field via fields/custom_fields)."
+    inputs_schema:
+      properties:
+        id: { type: string, description: "Ticket sys_id to update" }
+        ticket_type: { type: string, description: "Ticket table (default from instance config)" }
+        short_description: { type: string, description: "Short description (title)" }
+        description: { type: string, description: "Full description" }
+        urgency: { type: string, description: "Urgency (1, 2 or 3)" }
+        impact: { type: string, description: "Impact (1, 2 or 3)" }
+        priority: { type: string, description: "Priority (1-Critical … 5-Planning)" }
+        state: { type: string, description: "State code (numeric, table-specific — e.g. incident 6=Resolved, 7=Closed)" }
+        category: { type: string, description: "Category" }
+        subcategory: { type: string, description: "Subcategory" }
+        caller_id: { type: string, description: "Caller (sys_id or exact user name)" }
+        assigned_to: { type: string, description: "Assignee (sys_id or exact user name)" }
+        assignment_group: { type: string, description: "Assignment group (sys_id or exact group name)" }
+        close_code: { type: string, description: "Close code (required by most instances when resolving)" }
+        close_notes: { type: string, description: "Close notes (required by most instances when resolving)" }
+        comments: { type: string, description: "Customer-visible comment to add" }
+        work_notes: { type: string, description: "Internal work note to add" }
+        fields: { type: string, description: "Additional fields as name=value;name2=value2" }
+        custom_fields: { type: string, description: "Custom fields as name=value;name2=value2 (u_ prefix added when missing)" }
+        input_display_value: { type: boolean, description: "Treat input values as display values (sysparm_input_display_value)" }
+      required: [id]
+    outputs_schema: { properties: {} }
+  - id: delete_ticket
+    name: servicenow-delete-ticket
+    description: "Delete a ticket by sys_id."
+    inputs_schema:
+      properties:
+        id: { type: string, description: "Ticket sys_id to delete" }
+        ticket_type: { type: string, description: "Ticket table (default from instance config)" }
+      required: [id]
+    outputs_schema: { properties: {} }
+  - id: query_tickets
+    name: servicenow-query-tickets
+    description: "Query tickets with an encoded sysparm_query (e.g. active=true^priority=1^ORDERBYDESCopened_at)."
+    risk: read
+    inputs_schema:
+      properties:
+        query: { type: string, description: "Encoded sysparm_query" }
+        ticket_type: { type: string, description: "Ticket table (default from instance config)" }
+        fields: { type: string, description: "Comma-separated fields to return (sys_id always included)" }
+        limit: { type: number, description: "Maximum records (default 10)" }
+        offset: { type: number, description: "Starting record index (default 0)" }
+        display_value: { type: string, description: "sysparm_display_value: true, false or all (default false)" }
+      required: []
+    outputs_schema: { properties: {} }
+  - id: add_comment
+    name: servicenow-add-comment
+    description: "Add a customer-visible comment or an internal work note to a ticket."
+    inputs_schema:
+      properties:
+        id: { type: string, description: "Ticket sys_id" }
+        comment: { type: string, description: "Text to add" }
+        ticket_type: { type: string, description: "Ticket table (default from instance config)" }
+        work_note: { type: boolean, description: "Add as internal work note instead of customer-visible comment" }
+      required: [id, comment]
+    outputs_schema: { properties: {} }
+  - id: add_link
+    name: servicenow-add-link
+    description: "Post a clickable link (with optional text) into a ticket's comments or work notes."
+    inputs_schema:
+      properties:
+        id: { type: string, description: "Ticket sys_id" }
+        link: { type: string, description: "URL to post" }
+        text: { type: string, description: "Link text (defaults to the URL)" }
+        ticket_type: { type: string, description: "Ticket table (default from instance config)" }
+        work_note: { type: boolean, description: "Post into work notes instead of comments" }
+      required: [id, link]
+    outputs_schema: { properties: {} }
+  - id: add_tag
+    name: servicenow-add-tag
+    description: "Attach an existing tag (label) to a ticket via the label_entry table."
+    inputs_schema:
+      properties:
+        id: { type: string, description: "Ticket sys_id" }
+        tag_id: { type: string, description: "Tag (label) sys_id — find it with servicenow-query-table on the label table" }
+        title: { type: string, description: "Entry title, e.g. 'Incident - INC0010001'" }
+        ticket_type: { type: string, description: "Ticket table (default from instance config)" }
+      required: [id, tag_id, title]
+    outputs_schema: { properties: {} }
+  - id: get_ticket_notes
+    name: servicenow-get-ticket-notes
+    description: "Retrieve a ticket's comments and work notes from the journal (requires read access to sys_journal_field)."
+    risk: read
+    inputs_schema:
+      properties:
+        id: { type: string, description: "Ticket sys_id" }
+        limit: { type: number, description: "Maximum notes (default 10)" }
+        offset: { type: number, description: "Starting record index (default 0)" }
+      required: [id]
+    outputs_schema: { properties: {} }
+  - id: get_ticket_attachments
+    name: servicenow-get-ticket-attachments
+    description: "List attachment metadata (name, size, content type, download link) for a record."
+    risk: read
+    inputs_schema:
+      properties:
+        id: { type: string, description: "Record sys_id the attachments belong to" }
+      required: [id]
+    outputs_schema: { properties: {} }
+  - id: upload_file
+    name: servicenow-upload-file
+    description: "Attach a file to a record (content provided as base64)."
+    inputs_schema:
+      properties:
+        id: { type: string, description: "Record sys_id to attach the file to" }
+        file_name: { type: string, description: "File name (extension drives the content type)" }
+        content_base64: { type: string, description: "File content, base64-encoded" }
+        table_name: { type: string, description: "Table of the record (default from the instance ticket_type)" }
+      required: [id, file_name, content_base64]
+    outputs_schema: { properties: {} }
+  - id: delete_file
+    name: servicenow-delete-file
+    description: "Delete an attachment by its attachment sys_id."
+    inputs_schema:
+      properties:
+        file_sys_id: { type: string, description: "Attachment sys_id (from servicenow-get-ticket-attachments)" }
+      required: [file_sys_id]
+    outputs_schema: { properties: {} }
+
+  # ── Records / tables ──────────────────────────────────────────────────────
+  - id: get_record
+    name: servicenow-get-record
+    description: "Retrieve a single record from any table by sys_id."
+    risk: read
+    inputs_schema:
+      properties:
+        table_name: { type: string, description: "Table name (e.g. alm_asset)" }
+        id: { type: string, description: "Record sys_id" }
+        fields: { type: string, description: "Comma-separated fields to return (sys_id always included)" }
+        display_value: { type: string, description: "sysparm_display_value: true, false or all (default false)" }
+      required: [table_name, id]
+    outputs_schema: { properties: {} }
+  - id: create_record
+    name: servicenow-create-record
+    description: "Create a record in any table."
+    inputs_schema:
+      properties:
+        table_name: { type: string, description: "Table name" }
+        fields: { type: string, description: "Fields as name=value;name2=value2" }
+        custom_fields: { type: string, description: "Custom fields as name=value;name2=value2 (u_ prefix added when missing)" }
+        input_display_value: { type: boolean, description: "Treat input values as display values (sysparm_input_display_value)" }
+      required: [table_name]
+    outputs_schema: { properties: {} }
+  - id: update_record
+    name: servicenow-update-record
+    description: "Update a record in any table by sys_id."
+    inputs_schema:
+      properties:
+        table_name: { type: string, description: "Table name" }
+        id: { type: string, description: "Record sys_id" }
+        fields: { type: string, description: "Fields as name=value;name2=value2" }
+        custom_fields: { type: string, description: "Custom fields as name=value;name2=value2 (u_ prefix added when missing)" }
+        input_display_value: { type: boolean, description: "Treat input values as display values (sysparm_input_display_value)" }
+      required: [table_name, id]
+    outputs_schema: { properties: {} }
+  - id: delete_record
+    name: servicenow-delete-record
+    description: "Delete a record from any table by sys_id."
+    inputs_schema:
+      properties:
+        table_name: { type: string, description: "Table name" }
+        id: { type: string, description: "Record sys_id" }
+      required: [table_name, id]
+    outputs_schema: { properties: {} }
+  - id: query_table
+    name: servicenow-query-table
+    description: "Query any table with an encoded sysparm_query."
+    risk: read
+    inputs_schema:
+      properties:
+        table_name: { type: string, description: "Table name" }
+        query: { type: string, description: "Encoded sysparm_query" }
+        fields: { type: string, description: "Comma-separated fields to return (sys_id always included)" }
+        limit: { type: number, description: "Maximum records (default 10)" }
+        offset: { type: number, description: "Starting record index (default 0)" }
+        display_value: { type: string, description: "sysparm_display_value: true, false or all (default false)" }
+      required: [table_name]
+    outputs_schema: { properties: {} }
+  - id: list_table_fields
+    name: servicenow-list-table-fields
+    description: "List the API field names of a table (from a sample record)."
+    risk: read
+    inputs_schema:
+      properties:
+        table_name: { type: string, description: "Table name" }
+      required: [table_name]
+    outputs_schema: { properties: {} }
+  - id: get_table_name
+    name: servicenow-get-table-name
+    description: "Resolve table names from a display label (e.g. label 'Asset' → alm_asset) via sys_db_object."
+    risk: read
+    inputs_schema:
+      properties:
+        label: { type: string, description: "Table display label (e.g. Asset, Incident, IP address)" }
+        limit: { type: number, description: "Maximum results (default 10)" }
+      required: [label]
+    outputs_schema: { properties: {} }
+
+  # ── CMDB / users / groups ─────────────────────────────────────────────────
+  - id: query_computers
+    name: servicenow-query-computers
+    description: "Query the cmdb_ci_computer table by sys_id, name, asset tag or encoded query."
+    risk: read
+    inputs_schema:
+      properties:
+        computer_id: { type: string, description: "Computer sys_id" }
+        computer_name: { type: string, description: "Exact computer name" }
+        asset_tag: { type: string, description: "Asset tag" }
+        query: { type: string, description: "Encoded sysparm_query (used when no other filter is given)" }
+        limit: { type: number, description: "Maximum records (default 10)" }
+        offset: { type: number, description: "Starting record index (default 0)" }
+      required: []
+    outputs_schema: { properties: {} }
+  - id: query_groups
+    name: servicenow-query-groups
+    description: "Query the sys_user_group table by sys_id, name or encoded query."
+    risk: read
+    inputs_schema:
+      properties:
+        group_id: { type: string, description: "Group sys_id" }
+        group_name: { type: string, description: "Exact group name" }
+        query: { type: string, description: "Encoded sysparm_query (used when no other filter is given)" }
+        limit: { type: number, description: "Maximum records (default 10)" }
+        offset: { type: number, description: "Starting record index (default 0)" }
+      required: []
+    outputs_schema: { properties: {} }
+  - id: query_users
+    name: servicenow-query-users
+    description: "Query the sys_user table by sys_id, username or encoded query."
+    risk: read
+    inputs_schema:
+      properties:
+        user_id: { type: string, description: "User sys_id" }
+        user_name: { type: string, description: "Exact username (user_name field)" }
+        query: { type: string, description: "Encoded sysparm_query (used when no other filter is given)" }
+        limit: { type: number, description: "Maximum records (default 10)" }
+        offset: { type: number, description: "Starting record index (default 0)" }
+      required: []
+    outputs_schema: { properties: {} }
+
+  # ── Service catalog ───────────────────────────────────────────────────────
+  - id: query_items
+    name: servicenow-query-items
+    description: "Search service catalog items by name (Service Catalog API)."
+    risk: read
+    inputs_schema:
+      properties:
+        name: { type: string, description: "Free-text search (partial match)" }
+        limit: { type: number, description: "Maximum items (default 10)" }
+        offset: { type: number, description: "Starting record index (default 0)" }
+      required: []
+    outputs_schema: { properties: {} }
+  - id: get_item_details
+    name: servicenow-get-item-details
+    description: "Get a catalog item's details, including its order variables (Service Catalog API)."
+    risk: read
+    inputs_schema:
+      properties:
+        id: { type: string, description: "Catalog item sys_id" }
+      required: [id]
+    outputs_schema: { properties: {} }
+  - id: create_item_order
+    name: servicenow-create-item-order
+    description: "Order a catalog item (order_now). Mandatory item variables must be provided."
+    inputs_schema:
+      properties:
+        id: { type: string, description: "Catalog item sys_id" }
+        quantity: { type: number, description: "Quantity to order (default 1)" }
+        variables: { type: string, description: "Item variables as name=value;name2=value2 (see servicenow-get-item-details)" }
+      required: [id]
+    outputs_schema: { properties: {} }
+
+  # ── Change management ─────────────────────────────────────────────────────
+  - id: create_change_from_template
+    name: servicenow-create-change-from-template
+    description: "Create a standard change request from a standard change template (Change Management API)."
+    inputs_schema:
+      properties:
+        template: { type: string, description: "Standard change template sys_id" }
+      required: [template]
+    outputs_schema: { properties: {} }
+  - id: get_change_tasks
+    name: servicenow-get-change-tasks
+    description: "List the tasks of a change request (Change Management API)."
+    risk: read
+    inputs_schema:
+      properties:
+        id: { type: string, description: "Change request sys_id" }
+      required: [id]
+    outputs_schema: { properties: {} }
+
+  # ── Misc ──────────────────────────────────────────────────────────────────
+  - id: document_route_to_queue
+    name: servicenow-document-route-to-queue
+    description: "Route a document (ticket/record) to an Advanced Work Assignment queue."
+    inputs_schema:
+      properties:
+        queue_id: { type: string, description: "Queue sys_id (awa_queue table)" }
+        document_id: { type: string, description: "Document sys_id to route" }
+        document_table: { type: string, description: "Document table (default incident)" }
+      required: [queue_id, document_id]
+    outputs_schema: { properties: {} }
+  - id: generic_api_call
+    name: servicenow-generic-api-call
+    description: "Call any instance REST endpoint (path relative to the instance URL, e.g. /api/now/table/incident)."
+    inputs_schema:
+      properties:
+        method: { type: string, description: "HTTP method: GET, POST, PATCH, PUT or DELETE" }
+        path: { type: string, description: "Endpoint path starting with / (e.g. /api/now/table/incident)" }
+        params: { type: string, description: "Query parameters as JSON object (e.g. {\"sysparm_limit\":\"5\"})" }
+        body: { type: string, description: "Request body as JSON (POST/PATCH/PUT)" }
+      required: [method, path]
+    outputs_schema: { properties: {} }
+
+  - id: test_connection
+    name: servicenow-test-connection
+    description: "Verify connectivity and credentials (used by the Test button)."
+    risk: read
+    inputs_schema:
+      properties: {}
+      required: []
+    outputs_schema: { properties: {} }
+
+ingestion:
+  command: get_incidents
+  mapper: get_incidents
+  default_incident_type: "ServiceNow Ticket"

integrations/servicenow/mappers/get_incidents.yaml

@@ -0,0 +1,28 @@
+name: "ServiceNow Tickets → OCSF"
+description: "Maps a ServiceNow ticket (Table API, results_path = result) to OCSF finding fields. Reference fields (assigned_to, caller_id, cmdb_ci, …) are {value, link} objects in raw mode and {value, display_value} objects when the fetch uses sysparm_display_value=all — both path variants are listed and absent ones are skipped safely."
+field_mappings:
+  title: "short_description"
+  severity: "priority = '1' ? 5 : (priority = '2' ? 4 : (priority = '3' ? 3 : 2))"
+  description: "description"
+# results_path = result; source_path is JSONata over ONE ticket object.
+# Paths absent from a given ticket are skipped at ingestion, so extra entries are safe.
+ocsf:
+  # ── Finding ───────────────────────────────────────────────────────
+  - { source_path: "sys_id",            ocsf_field: "finding_info.uid" }
+  - { source_path: "number",            ocsf_field: "finding_info.uid_alt" }
+  - { source_path: "short_description", ocsf_field: "finding_info.title" }
+  - { source_path: "description",       ocsf_field: "finding_info.desc" }
+  - { source_path: "opened_at",         ocsf_field: "finding_info.first_seen_time" }
+  - { source_path: "sys_created_on",    ocsf_field: "finding_info.created_time" }
+  - { source_path: "sys_updated_on",    ocsf_field: "finding_info.modified_time" }
+  - { source_path: "category",          ocsf_field: "finding_info.analytic.category" }
+  - { source_path: "subcategory",       ocsf_field: "finding_info.types" }
+  - { source_path: "state",             ocsf_field: "status" }
+  - { source_path: "close_code",        ocsf_field: "disposition" }
+  - { source_path: "close_notes",       ocsf_field: "comment" }
+  # ── People ────────────────────────────────────────────────────────
+  - { source_path: "sys_created_by",              ocsf_field: "actor.user.name" }
+  - { source_path: "caller_id.display_value",     ocsf_field: "user.name" }
+  - { source_path: "assigned_to.display_value",   ocsf_field: "assignee.name" }
+  # ── Affected CI ───────────────────────────────────────────────────
+  - { source_path: "cmdb_ci.display_value",       ocsf_field: "device.hostname" }

integrations/servicenow/scripts/add_comment.py

@@ -0,0 +1,64 @@
+import base64, json, os, sys, urllib.parse, urllib.request, urllib.error
+
+
+def _cfg():
+    return json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+
+
+def _headers(cfg):
+    h = {"Accept": "application/json", "Content-Type": "application/json"}
+    if str(cfg.get("auth_type") or "basic").lower() == "oauth":
+        data = urllib.parse.urlencode({
+            "grant_type": "password",
+            "client_id": cfg.get("client_id", ""),
+            "client_secret": cfg.get("client_secret", ""),
+            "username": cfg.get("username", ""),
+            "password": cfg.get("password", ""),
+        }).encode("utf-8")
+        req = urllib.request.Request(
+            cfg.get("url", "").rstrip("/") + "/oauth_token.do", data=data,
+            headers={"Content-Type": "application/x-www-form-urlencoded", "Accept": "application/json"}, method="POST")
+        with urllib.request.urlopen(req, timeout=60) as r:
+            tok = json.loads(r.read())
+        if not tok.get("access_token"):
+            raise Exception("OAuth token request failed: " + json.dumps(tok))
+        h["Authorization"] = "Bearer " + tok["access_token"]
+    else:
+        cred = (cfg.get("username", "") + ":" + cfg.get("password", "")).encode("utf-8")
+        h["Authorization"] = "Basic " + base64.b64encode(cred).decode("ascii")
+    return h
+
+
+def request(method, path, params=None, body=None, root="/api/now", versioned=True):
+    cfg = _cfg()
+    v = str(cfg.get("api_version") or "").strip().strip("/")
+    url = cfg.get("url", "").rstrip("/") + root + ("/" + v if v and versioned else "") + path
+    q = {k: str(x) for k, x in (params or {}).items() if x not in (None, "")}
+    if q:
+        url += "?" + urllib.parse.urlencode(q)
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=_headers(cfg), method=method)
+    with urllib.request.urlopen(req, timeout=90) as r:
+        raw = r.read()
+        return json.loads(raw) if raw else {}
+
+
+def main():
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    ticket_id = str(inputs.get("id") or "")
+    if not ticket_id:
+        raise Exception("id is required")
+    table = str(inputs.get("ticket_type") or _cfg().get("ticket_type") or "incident")
+    key = "work_notes" if inputs.get("work_note") else "comments"
+    body = {key: str(inputs.get("comment") or "")}
+    print(json.dumps(request("PATCH", "/table/" + urllib.parse.quote(table) + "/" + urllib.parse.quote(ticket_id), body=body)))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/servicenow/scripts/add_link.py

@@ -0,0 +1,67 @@
+import base64, json, os, sys, urllib.parse, urllib.request, urllib.error
+
+
+def _cfg():
+    return json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+
+
+def _headers(cfg):
+    h = {"Accept": "application/json", "Content-Type": "application/json"}
+    if str(cfg.get("auth_type") or "basic").lower() == "oauth":
+        data = urllib.parse.urlencode({
+            "grant_type": "password",
+            "client_id": cfg.get("client_id", ""),
+            "client_secret": cfg.get("client_secret", ""),
+            "username": cfg.get("username", ""),
+            "password": cfg.get("password", ""),
+        }).encode("utf-8")
+        req = urllib.request.Request(
+            cfg.get("url", "").rstrip("/") + "/oauth_token.do", data=data,
+            headers={"Content-Type": "application/x-www-form-urlencoded", "Accept": "application/json"}, method="POST")
+        with urllib.request.urlopen(req, timeout=60) as r:
+            tok = json.loads(r.read())
+        if not tok.get("access_token"):
+            raise Exception("OAuth token request failed: " + json.dumps(tok))
+        h["Authorization"] = "Bearer " + tok["access_token"]
+    else:
+        cred = (cfg.get("username", "") + ":" + cfg.get("password", "")).encode("utf-8")
+        h["Authorization"] = "Basic " + base64.b64encode(cred).decode("ascii")
+    return h
+
+
+def request(method, path, params=None, body=None, root="/api/now", versioned=True):
+    cfg = _cfg()
+    v = str(cfg.get("api_version") or "").strip().strip("/")
+    url = cfg.get("url", "").rstrip("/") + root + ("/" + v if v and versioned else "") + path
+    q = {k: str(x) for k, x in (params or {}).items() if x not in (None, "")}
+    if q:
+        url += "?" + urllib.parse.urlencode(q)
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=_headers(cfg), method=method)
+    with urllib.request.urlopen(req, timeout=90) as r:
+        raw = r.read()
+        return json.loads(raw) if raw else {}
+
+
+def main():
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    ticket_id = str(inputs.get("id") or "")
+    if not ticket_id:
+        raise Exception("id is required")
+    table = str(inputs.get("ticket_type") or _cfg().get("ticket_type") or "incident")
+    link = str(inputs.get("link") or "")
+    text = str(inputs.get("text") or link)
+    html = '[code]<a class="web" target="_blank" href="' + link + '">' + text + '</a>[/code]'
+    key = "work_notes" if inputs.get("work_note") else "comments"
+    body = {key: html}
+    print(json.dumps(request("PATCH", "/table/" + urllib.parse.quote(table) + "/" + urllib.parse.quote(ticket_id), body=body)))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/servicenow/scripts/add_tag.py

@@ -0,0 +1,68 @@
+import base64, json, os, sys, urllib.parse, urllib.request, urllib.error
+
+
+def _cfg():
+    return json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+
+
+def _headers(cfg):
+    h = {"Accept": "application/json", "Content-Type": "application/json"}
+    if str(cfg.get("auth_type") or "basic").lower() == "oauth":
+        data = urllib.parse.urlencode({
+            "grant_type": "password",
+            "client_id": cfg.get("client_id", ""),
+            "client_secret": cfg.get("client_secret", ""),
+            "username": cfg.get("username", ""),
+            "password": cfg.get("password", ""),
+        }).encode("utf-8")
+        req = urllib.request.Request(
+            cfg.get("url", "").rstrip("/") + "/oauth_token.do", data=data,
+            headers={"Content-Type": "application/x-www-form-urlencoded", "Accept": "application/json"}, method="POST")
+        with urllib.request.urlopen(req, timeout=60) as r:
+            tok = json.loads(r.read())
+        if not tok.get("access_token"):
+            raise Exception("OAuth token request failed: " + json.dumps(tok))
+        h["Authorization"] = "Bearer " + tok["access_token"]
+    else:
+        cred = (cfg.get("username", "") + ":" + cfg.get("password", "")).encode("utf-8")
+        h["Authorization"] = "Basic " + base64.b64encode(cred).decode("ascii")
+    return h
+
+
+def request(method, path, params=None, body=None, root="/api/now", versioned=True):
+    cfg = _cfg()
+    v = str(cfg.get("api_version") or "").strip().strip("/")
+    url = cfg.get("url", "").rstrip("/") + root + ("/" + v if v and versioned else "") + path
+    q = {k: str(x) for k, x in (params or {}).items() if x not in (None, "")}
+    if q:
+        url += "?" + urllib.parse.urlencode(q)
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=_headers(cfg), method=method)
+    with urllib.request.urlopen(req, timeout=90) as r:
+        raw = r.read()
+        return json.loads(raw) if raw else {}
+
+
+def main():
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    ticket_id = str(inputs.get("id") or "")
+    if not ticket_id:
+        raise Exception("id is required")
+    table = str(inputs.get("ticket_type") or _cfg().get("ticket_type") or "incident")
+    body = {
+        "label": str(inputs.get("tag_id") or ""),
+        "table": table,
+        "table_key": ticket_id,
+        "title": str(inputs.get("title") or ""),
+    }
+    print(json.dumps(request("POST", "/table/label_entry", body=body)))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/servicenow/scripts/create_change_from_template.py

@@ -0,0 +1,60 @@
+import base64, json, os, sys, urllib.parse, urllib.request, urllib.error
+
+
+def _cfg():
+    return json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+
+
+def _headers(cfg):
+    h = {"Accept": "application/json", "Content-Type": "application/json"}
+    if str(cfg.get("auth_type") or "basic").lower() == "oauth":
+        data = urllib.parse.urlencode({
+            "grant_type": "password",
+            "client_id": cfg.get("client_id", ""),
+            "client_secret": cfg.get("client_secret", ""),
+            "username": cfg.get("username", ""),
+            "password": cfg.get("password", ""),
+        }).encode("utf-8")
+        req = urllib.request.Request(
+            cfg.get("url", "").rstrip("/") + "/oauth_token.do", data=data,
+            headers={"Content-Type": "application/x-www-form-urlencoded", "Accept": "application/json"}, method="POST")
+        with urllib.request.urlopen(req, timeout=60) as r:
+            tok = json.loads(r.read())
+        if not tok.get("access_token"):
+            raise Exception("OAuth token request failed: " + json.dumps(tok))
+        h["Authorization"] = "Bearer " + tok["access_token"]
+    else:
+        cred = (cfg.get("username", "") + ":" + cfg.get("password", "")).encode("utf-8")
+        h["Authorization"] = "Basic " + base64.b64encode(cred).decode("ascii")
+    return h
+
+
+def request(method, path, params=None, body=None, root="/api/now", versioned=True):
+    cfg = _cfg()
+    v = str(cfg.get("api_version") or "").strip().strip("/")
+    url = cfg.get("url", "").rstrip("/") + root + ("/" + v if v and versioned else "") + path
+    q = {k: str(x) for k, x in (params or {}).items() if x not in (None, "")}
+    if q:
+        url += "?" + urllib.parse.urlencode(q)
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=_headers(cfg), method=method)
+    with urllib.request.urlopen(req, timeout=90) as r:
+        raw = r.read()
+        return json.loads(raw) if raw else {}
+
+
+def main():
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    template = inputs.get("template") or ""
+    res = request("POST", "/change/standard/" + urllib.parse.quote(template), root="/api/sn_chg_rest", body={})
+    print(json.dumps(res))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/servicenow/scripts/create_item_order.py

@@ -0,0 +1,78 @@
+import base64, json, os, sys, urllib.parse, urllib.request, urllib.error
+
+
+def _cfg():
+    return json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+
+
+def _headers(cfg):
+    h = {"Accept": "application/json", "Content-Type": "application/json"}
+    if str(cfg.get("auth_type") or "basic").lower() == "oauth":
+        data = urllib.parse.urlencode({
+            "grant_type": "password",
+            "client_id": cfg.get("client_id", ""),
+            "client_secret": cfg.get("client_secret", ""),
+            "username": cfg.get("username", ""),
+            "password": cfg.get("password", ""),
+        }).encode("utf-8")
+        req = urllib.request.Request(
+            cfg.get("url", "").rstrip("/") + "/oauth_token.do", data=data,
+            headers={"Content-Type": "application/x-www-form-urlencoded", "Accept": "application/json"}, method="POST")
+        with urllib.request.urlopen(req, timeout=60) as r:
+            tok = json.loads(r.read())
+        if not tok.get("access_token"):
+            raise Exception("OAuth token request failed: " + json.dumps(tok))
+        h["Authorization"] = "Bearer " + tok["access_token"]
+    else:
+        cred = (cfg.get("username", "") + ":" + cfg.get("password", "")).encode("utf-8")
+        h["Authorization"] = "Basic " + base64.b64encode(cred).decode("ascii")
+    return h
+
+
+def request(method, path, params=None, body=None, root="/api/now", versioned=True):
+    cfg = _cfg()
+    v = str(cfg.get("api_version") or "").strip().strip("/")
+    url = cfg.get("url", "").rstrip("/") + root + ("/" + v if v and versioned else "") + path
+    q = {k: str(x) for k, x in (params or {}).items() if x not in (None, "")}
+    if q:
+        url += "?" + urllib.parse.urlencode(q)
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=_headers(cfg), method=method)
+    with urllib.request.urlopen(req, timeout=90) as r:
+        raw = r.read()
+        return json.loads(raw) if raw else {}
+
+
+def split_fields(s, prefix_custom=False):
+    out = {}
+    for part in str(s or "").split(";"):
+        if "=" not in part:
+            continue
+        k, v = part.split("=", 1)
+        k = k.strip()
+        if prefix_custom and k and not k.startswith("u_"):
+            k = "u_" + k
+        if k:
+            out[k] = v
+    return out
+
+
+def main():
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    iid = inputs.get("id") or ""
+    body = {
+        "sysparm_quantity": str(int(inputs.get("quantity") or 1)),
+        "variables": split_fields(inputs.get("variables")),
+    }
+    res = request("POST", "/servicecatalog/items/" + urllib.parse.quote(iid) + "/order_now", root="/api/sn_sc", body=body)
+    print(json.dumps(res))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/servicenow/scripts/create_record.py

@@ -0,0 +1,79 @@
+import base64, json, os, sys, urllib.parse, urllib.request, urllib.error
+
+
+def _cfg():
+    return json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+
+
+def _headers(cfg):
+    h = {"Accept": "application/json", "Content-Type": "application/json"}
+    if str(cfg.get("auth_type") or "basic").lower() == "oauth":
+        data = urllib.parse.urlencode({
+            "grant_type": "password",
+            "client_id": cfg.get("client_id", ""),
+            "client_secret": cfg.get("client_secret", ""),
+            "username": cfg.get("username", ""),
+            "password": cfg.get("password", ""),
+        }).encode("utf-8")
+        req = urllib.request.Request(
+            cfg.get("url", "").rstrip("/") + "/oauth_token.do", data=data,
+            headers={"Content-Type": "application/x-www-form-urlencoded", "Accept": "application/json"}, method="POST")
+        with urllib.request.urlopen(req, timeout=60) as r:
+            tok = json.loads(r.read())
+        if not tok.get("access_token"):
+            raise Exception("OAuth token request failed: " + json.dumps(tok))
+        h["Authorization"] = "Bearer " + tok["access_token"]
+    else:
+        cred = (cfg.get("username", "") + ":" + cfg.get("password", "")).encode("utf-8")
+        h["Authorization"] = "Basic " + base64.b64encode(cred).decode("ascii")
+    return h
+
+
+def request(method, path, params=None, body=None, root="/api/now", versioned=True):
+    cfg = _cfg()
+    v = str(cfg.get("api_version") or "").strip().strip("/")
+    url = cfg.get("url", "").rstrip("/") + root + ("/" + v if v and versioned else "") + path
+    q = {k: str(x) for k, x in (params or {}).items() if x not in (None, "")}
+    if q:
+        url += "?" + urllib.parse.urlencode(q)
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=_headers(cfg), method=method)
+    with urllib.request.urlopen(req, timeout=90) as r:
+        raw = r.read()
+        return json.loads(raw) if raw else {}
+
+
+def split_fields(s, prefix_custom=False):
+    out = {}
+    for part in str(s or "").split(";"):
+        if "=" not in part:
+            continue
+        k, v = part.split("=", 1)
+        k = k.strip()
+        if prefix_custom and k and not k.startswith("u_"):
+            k = "u_" + k
+        if k:
+            out[k] = v
+    return out
+
+
+def main():
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    table = inputs.get("table_name") or ""
+    body = split_fields(inputs.get("fields"))
+    body.update(split_fields(inputs.get("custom_fields"), prefix_custom=True))
+    if not body:
+        raise Exception("no fields to set")
+    params = {"sysparm_input_display_value": "true"} if inputs.get("input_display_value") else None
+    res = request("POST", "/table/" + urllib.parse.quote(table), params=params, body=body)
+    print(json.dumps(res))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/servicenow/scripts/create_ticket.py

@@ -0,0 +1,88 @@
+import base64, json, os, sys, urllib.parse, urllib.request, urllib.error
+
+
+def _cfg():
+    return json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+
+
+def _headers(cfg):
+    h = {"Accept": "application/json", "Content-Type": "application/json"}
+    if str(cfg.get("auth_type") or "basic").lower() == "oauth":
+        data = urllib.parse.urlencode({
+            "grant_type": "password",
+            "client_id": cfg.get("client_id", ""),
+            "client_secret": cfg.get("client_secret", ""),
+            "username": cfg.get("username", ""),
+            "password": cfg.get("password", ""),
+        }).encode("utf-8")
+        req = urllib.request.Request(
+            cfg.get("url", "").rstrip("/") + "/oauth_token.do", data=data,
+            headers={"Content-Type": "application/x-www-form-urlencoded", "Accept": "application/json"}, method="POST")
+        with urllib.request.urlopen(req, timeout=60) as r:
+            tok = json.loads(r.read())
+        if not tok.get("access_token"):
+            raise Exception("OAuth token request failed: " + json.dumps(tok))
+        h["Authorization"] = "Bearer " + tok["access_token"]
+    else:
+        cred = (cfg.get("username", "") + ":" + cfg.get("password", "")).encode("utf-8")
+        h["Authorization"] = "Basic " + base64.b64encode(cred).decode("ascii")
+    return h
+
+
+def request(method, path, params=None, body=None, root="/api/now", versioned=True):
+    cfg = _cfg()
+    v = str(cfg.get("api_version") or "").strip().strip("/")
+    url = cfg.get("url", "").rstrip("/") + root + ("/" + v if v and versioned else "") + path
+    q = {k: str(x) for k, x in (params or {}).items() if x not in (None, "")}
+    if q:
+        url += "?" + urllib.parse.urlencode(q)
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=_headers(cfg), method=method)
+    with urllib.request.urlopen(req, timeout=90) as r:
+        raw = r.read()
+        return json.loads(raw) if raw else {}
+
+
+def split_fields(s, prefix_custom=False):
+    out = {}
+    for part in str(s or "").split(";"):
+        if "=" not in part:
+            continue
+        k, v = part.split("=", 1)
+        k = k.strip()
+        if prefix_custom and k and not k.startswith("u_"):
+            k = "u_" + k
+        if k:
+            out[k] = v
+    return out
+
+
+NAMED_FIELDS = [
+    "short_description", "description", "urgency", "impact", "priority", "state",
+    "category", "subcategory", "caller_id", "assigned_to", "assignment_group",
+    "comments", "work_notes",
+]
+
+
+def main():
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    table = str(inputs.get("ticket_type") or _cfg().get("ticket_type") or "incident")
+    body = {}
+    for k in NAMED_FIELDS:
+        v = inputs.get(k)
+        if v not in (None, ""):
+            body[k] = v
+    body.update(split_fields(inputs.get("fields")))
+    body.update(split_fields(inputs.get("custom_fields"), prefix_custom=True))
+    params = {"sysparm_input_display_value": "true"} if inputs.get("input_display_value") else None
+    print(json.dumps(request("POST", "/table/" + urllib.parse.quote(table), params=params, body=body)))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/servicenow/scripts/delete_file.py

@@ -0,0 +1,62 @@
+import base64, json, os, sys, urllib.parse, urllib.request, urllib.error
+
+
+def _cfg():
+    return json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+
+
+def _headers(cfg):
+    h = {"Accept": "application/json", "Content-Type": "application/json"}
+    if str(cfg.get("auth_type") or "basic").lower() == "oauth":
+        data = urllib.parse.urlencode({
+            "grant_type": "password",
+            "client_id": cfg.get("client_id", ""),
+            "client_secret": cfg.get("client_secret", ""),
+            "username": cfg.get("username", ""),
+            "password": cfg.get("password", ""),
+        }).encode("utf-8")
+        req = urllib.request.Request(
+            cfg.get("url", "").rstrip("/") + "/oauth_token.do", data=data,
+            headers={"Content-Type": "application/x-www-form-urlencoded", "Accept": "application/json"}, method="POST")
+        with urllib.request.urlopen(req, timeout=60) as r:
+            tok = json.loads(r.read())
+        if not tok.get("access_token"):
+            raise Exception("OAuth token request failed: " + json.dumps(tok))
+        h["Authorization"] = "Bearer " + tok["access_token"]
+    else:
+        cred = (cfg.get("username", "") + ":" + cfg.get("password", "")).encode("utf-8")
+        h["Authorization"] = "Basic " + base64.b64encode(cred).decode("ascii")
+    return h
+
+
+def request(method, path, params=None, body=None, root="/api/now", versioned=True):
+    cfg = _cfg()
+    v = str(cfg.get("api_version") or "").strip().strip("/")
+    url = cfg.get("url", "").rstrip("/") + root + ("/" + v if v and versioned else "") + path
+    q = {k: str(x) for k, x in (params or {}).items() if x not in (None, "")}
+    if q:
+        url += "?" + urllib.parse.urlencode(q)
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=_headers(cfg), method=method)
+    with urllib.request.urlopen(req, timeout=90) as r:
+        raw = r.read()
+        return json.loads(raw) if raw else {}
+
+
+def main():
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    file_sys_id = str(inputs.get("file_sys_id") or "")
+    if not file_sys_id:
+        raise Exception("file_sys_id is required")
+    res = request("DELETE", "/attachment/" + urllib.parse.quote(file_sys_id), versioned=False)
+    print(json.dumps(res if res else {"ok": True, "file_sys_id": file_sys_id}))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/servicenow/scripts/delete_record.py

@@ -0,0 +1,61 @@
+import base64, json, os, sys, urllib.parse, urllib.request, urllib.error
+
+
+def _cfg():
+    return json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+
+
+def _headers(cfg):
+    h = {"Accept": "application/json", "Content-Type": "application/json"}
+    if str(cfg.get("auth_type") or "basic").lower() == "oauth":
+        data = urllib.parse.urlencode({
+            "grant_type": "password",
+            "client_id": cfg.get("client_id", ""),
+            "client_secret": cfg.get("client_secret", ""),
+            "username": cfg.get("username", ""),
+            "password": cfg.get("password", ""),
+        }).encode("utf-8")
+        req = urllib.request.Request(
+            cfg.get("url", "").rstrip("/") + "/oauth_token.do", data=data,
+            headers={"Content-Type": "application/x-www-form-urlencoded", "Accept": "application/json"}, method="POST")
+        with urllib.request.urlopen(req, timeout=60) as r:
+            tok = json.loads(r.read())
+        if not tok.get("access_token"):
+            raise Exception("OAuth token request failed: " + json.dumps(tok))
+        h["Authorization"] = "Bearer " + tok["access_token"]
+    else:
+        cred = (cfg.get("username", "") + ":" + cfg.get("password", "")).encode("utf-8")
+        h["Authorization"] = "Basic " + base64.b64encode(cred).decode("ascii")
+    return h
+
+
+def request(method, path, params=None, body=None, root="/api/now", versioned=True):
+    cfg = _cfg()
+    v = str(cfg.get("api_version") or "").strip().strip("/")
+    url = cfg.get("url", "").rstrip("/") + root + ("/" + v if v and versioned else "") + path
+    q = {k: str(x) for k, x in (params or {}).items() if x not in (None, "")}
+    if q:
+        url += "?" + urllib.parse.urlencode(q)
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=_headers(cfg), method=method)
+    with urllib.request.urlopen(req, timeout=90) as r:
+        raw = r.read()
+        return json.loads(raw) if raw else {}
+
+
+def main():
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    table = inputs.get("table_name") or ""
+    rid = inputs.get("id") or ""
+    res = request("DELETE", "/table/" + urllib.parse.quote(table) + "/" + urllib.parse.quote(rid))
+    print(json.dumps(res if res else {"ok": True, "id": rid}))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/servicenow/scripts/delete_ticket.py

@@ -0,0 +1,63 @@
+import base64, json, os, sys, urllib.parse, urllib.request, urllib.error
+
+
+def _cfg():
+    return json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+
+
+def _headers(cfg):
+    h = {"Accept": "application/json", "Content-Type": "application/json"}
+    if str(cfg.get("auth_type") or "basic").lower() == "oauth":
+        data = urllib.parse.urlencode({
+            "grant_type": "password",
+            "client_id": cfg.get("client_id", ""),
+            "client_secret": cfg.get("client_secret", ""),
+            "username": cfg.get("username", ""),
+            "password": cfg.get("password", ""),
+        }).encode("utf-8")
+        req = urllib.request.Request(
+            cfg.get("url", "").rstrip("/") + "/oauth_token.do", data=data,
+            headers={"Content-Type": "application/x-www-form-urlencoded", "Accept": "application/json"}, method="POST")
+        with urllib.request.urlopen(req, timeout=60) as r:
+            tok = json.loads(r.read())
+        if not tok.get("access_token"):
+            raise Exception("OAuth token request failed: " + json.dumps(tok))
+        h["Authorization"] = "Bearer " + tok["access_token"]
+    else:
+        cred = (cfg.get("username", "") + ":" + cfg.get("password", "")).encode("utf-8")
+        h["Authorization"] = "Basic " + base64.b64encode(cred).decode("ascii")
+    return h
+
+
+def request(method, path, params=None, body=None, root="/api/now", versioned=True):
+    cfg = _cfg()
+    v = str(cfg.get("api_version") or "").strip().strip("/")
+    url = cfg.get("url", "").rstrip("/") + root + ("/" + v if v and versioned else "") + path
+    q = {k: str(x) for k, x in (params or {}).items() if x not in (None, "")}
+    if q:
+        url += "?" + urllib.parse.urlencode(q)
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=_headers(cfg), method=method)
+    with urllib.request.urlopen(req, timeout=90) as r:
+        raw = r.read()
+        return json.loads(raw) if raw else {}
+
+
+def main():
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    ticket_id = str(inputs.get("id") or "")
+    if not ticket_id:
+        raise Exception("id is required")
+    table = str(inputs.get("ticket_type") or _cfg().get("ticket_type") or "incident")
+    res = request("DELETE", "/table/" + urllib.parse.quote(table) + "/" + urllib.parse.quote(ticket_id))
+    print(json.dumps(res if res else {"ok": True, "id": ticket_id}))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/servicenow/scripts/document_route_to_queue.py

@@ -0,0 +1,64 @@
+import base64, json, os, sys, urllib.parse, urllib.request, urllib.error
+
+
+def _cfg():
+    return json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+
+
+def _headers(cfg):
+    h = {"Accept": "application/json", "Content-Type": "application/json"}
+    if str(cfg.get("auth_type") or "basic").lower() == "oauth":
+        data = urllib.parse.urlencode({
+            "grant_type": "password",
+            "client_id": cfg.get("client_id", ""),
+            "client_secret": cfg.get("client_secret", ""),
+            "username": cfg.get("username", ""),
+            "password": cfg.get("password", ""),
+        }).encode("utf-8")
+        req = urllib.request.Request(
+            cfg.get("url", "").rstrip("/") + "/oauth_token.do", data=data,
+            headers={"Content-Type": "application/x-www-form-urlencoded", "Accept": "application/json"}, method="POST")
+        with urllib.request.urlopen(req, timeout=60) as r:
+            tok = json.loads(r.read())
+        if not tok.get("access_token"):
+            raise Exception("OAuth token request failed: " + json.dumps(tok))
+        h["Authorization"] = "Bearer " + tok["access_token"]
+    else:
+        cred = (cfg.get("username", "") + ":" + cfg.get("password", "")).encode("utf-8")
+        h["Authorization"] = "Basic " + base64.b64encode(cred).decode("ascii")
+    return h
+
+
+def request(method, path, params=None, body=None, root="/api/now", versioned=True):
+    cfg = _cfg()
+    v = str(cfg.get("api_version") or "").strip().strip("/")
+    url = cfg.get("url", "").rstrip("/") + root + ("/" + v if v and versioned else "") + path
+    q = {k: str(x) for k, x in (params or {}).items() if x not in (None, "")}
+    if q:
+        url += "?" + urllib.parse.urlencode(q)
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=_headers(cfg), method=method)
+    with urllib.request.urlopen(req, timeout=90) as r:
+        raw = r.read()
+        return json.loads(raw) if raw else {}
+
+
+def main():
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    queue_id = inputs.get("queue_id") or ""
+    body = {
+        "document_sys_id": inputs.get("document_id") or "",
+        "document_table": inputs.get("document_table") or "incident",
+    }
+    res = request("POST", "/awa/queues/" + urllib.parse.quote(queue_id) + "/work_item", versioned=False, body=body)
+    print(json.dumps(res))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/servicenow/scripts/generic_api_call.py

@@ -0,0 +1,71 @@
+import base64, json, os, sys, urllib.parse, urllib.request, urllib.error
+
+
+def _cfg():
+    return json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+
+
+def _headers(cfg):
+    h = {"Accept": "application/json", "Content-Type": "application/json"}
+    if str(cfg.get("auth_type") or "basic").lower() == "oauth":
+        data = urllib.parse.urlencode({
+            "grant_type": "password",
+            "client_id": cfg.get("client_id", ""),
+            "client_secret": cfg.get("client_secret", ""),
+            "username": cfg.get("username", ""),
+            "password": cfg.get("password", ""),
+        }).encode("utf-8")
+        req = urllib.request.Request(
+            cfg.get("url", "").rstrip("/") + "/oauth_token.do", data=data,
+            headers={"Content-Type": "application/x-www-form-urlencoded", "Accept": "application/json"}, method="POST")
+        with urllib.request.urlopen(req, timeout=60) as r:
+            tok = json.loads(r.read())
+        if not tok.get("access_token"):
+            raise Exception("OAuth token request failed: " + json.dumps(tok))
+        h["Authorization"] = "Bearer " + tok["access_token"]
+    else:
+        cred = (cfg.get("username", "") + ":" + cfg.get("password", "")).encode("utf-8")
+        h["Authorization"] = "Basic " + base64.b64encode(cred).decode("ascii")
+    return h
+
+
+def main():
+    cfg = _cfg()
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    method = str(inputs.get("method") or "GET").upper()
+    if method not in ("GET", "POST", "PATCH", "PUT", "DELETE"):
+        raise Exception("Unsupported method: " + method)
+    path = str(inputs.get("path") or "")
+    if not path.startswith("/"):
+        raise Exception("path must start with /")
+
+    url = cfg.get("url", "").rstrip("/") + path
+    params = inputs.get("params")
+    if params:
+        if isinstance(params, str):
+            params = json.loads(params)
+        q = {k: str(v) for k, v in params.items() if v not in (None, "")}
+        if q:
+            url += ("&" if "?" in url else "?") + urllib.parse.urlencode(q)
+
+    body = inputs.get("body")
+    data = None
+    if body not in (None, ""):
+        if isinstance(body, str):
+            body = json.loads(body)
+        data = json.dumps(body).encode("utf-8")
+
+    req = urllib.request.Request(url, data=data, headers=_headers(cfg), method=method)
+    with urllib.request.urlopen(req, timeout=90) as r:
+        raw = r.read()
+        print(json.dumps(json.loads(raw) if raw else {}))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/servicenow/scripts/get_change_tasks.py

@@ -0,0 +1,60 @@
+import base64, json, os, sys, urllib.parse, urllib.request, urllib.error
+
+
+def _cfg():
+    return json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+
+
+def _headers(cfg):
+    h = {"Accept": "application/json", "Content-Type": "application/json"}
+    if str(cfg.get("auth_type") or "basic").lower() == "oauth":
+        data = urllib.parse.urlencode({
+            "grant_type": "password",
+            "client_id": cfg.get("client_id", ""),
+            "client_secret": cfg.get("client_secret", ""),
+            "username": cfg.get("username", ""),
+            "password": cfg.get("password", ""),
+        }).encode("utf-8")
+        req = urllib.request.Request(
+            cfg.get("url", "").rstrip("/") + "/oauth_token.do", data=data,
+            headers={"Content-Type": "application/x-www-form-urlencoded", "Accept": "application/json"}, method="POST")
+        with urllib.request.urlopen(req, timeout=60) as r:
+            tok = json.loads(r.read())
+        if not tok.get("access_token"):
+            raise Exception("OAuth token request failed: " + json.dumps(tok))
+        h["Authorization"] = "Bearer " + tok["access_token"]
+    else:
+        cred = (cfg.get("username", "") + ":" + cfg.get("password", "")).encode("utf-8")
+        h["Authorization"] = "Basic " + base64.b64encode(cred).decode("ascii")
+    return h
+
+
+def request(method, path, params=None, body=None, root="/api/now", versioned=True):
+    cfg = _cfg()
+    v = str(cfg.get("api_version") or "").strip().strip("/")
+    url = cfg.get("url", "").rstrip("/") + root + ("/" + v if v and versioned else "") + path
+    q = {k: str(x) for k, x in (params or {}).items() if x not in (None, "")}
+    if q:
+        url += "?" + urllib.parse.urlencode(q)
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=_headers(cfg), method=method)
+    with urllib.request.urlopen(req, timeout=90) as r:
+        raw = r.read()
+        return json.loads(raw) if raw else {}
+
+
+def main():
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    cid = inputs.get("id") or ""
+    res = request("GET", "/change/" + urllib.parse.quote(cid) + "/task", root="/api/sn_chg_rest")
+    print(json.dumps(res))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/servicenow/scripts/get_incidents.py

@@ -0,0 +1,96 @@
+import base64, json, os, sys, urllib.parse, urllib.request, urllib.error
+from datetime import datetime, timezone
+
+
+def _cfg():
+    return json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+
+
+def _headers(cfg):
+    h = {"Accept": "application/json", "Content-Type": "application/json"}
+    if str(cfg.get("auth_type") or "basic").lower() == "oauth":
+        data = urllib.parse.urlencode({
+            "grant_type": "password",
+            "client_id": cfg.get("client_id", ""),
+            "client_secret": cfg.get("client_secret", ""),
+            "username": cfg.get("username", ""),
+            "password": cfg.get("password", ""),
+        }).encode("utf-8")
+        req = urllib.request.Request(
+            cfg.get("url", "").rstrip("/") + "/oauth_token.do", data=data,
+            headers={"Content-Type": "application/x-www-form-urlencoded", "Accept": "application/json"}, method="POST")
+        with urllib.request.urlopen(req, timeout=60) as r:
+            tok = json.loads(r.read())
+        if not tok.get("access_token"):
+            raise Exception("OAuth token request failed: " + json.dumps(tok))
+        h["Authorization"] = "Bearer " + tok["access_token"]
+    else:
+        cred = (cfg.get("username", "") + ":" + cfg.get("password", "")).encode("utf-8")
+        h["Authorization"] = "Basic " + base64.b64encode(cred).decode("ascii")
+    return h
+
+
+def request(method, path, params=None, body=None, root="/api/now", versioned=True):
+    cfg = _cfg()
+    v = str(cfg.get("api_version") or "").strip().strip("/")
+    url = cfg.get("url", "").rstrip("/") + root + ("/" + v if v and versioned else "") + path
+    q = {k: str(x) for k, x in (params or {}).items() if x not in (None, "")}
+    if q:
+        url += "?" + urllib.parse.urlencode(q)
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=_headers(cfg), method=method)
+    with urllib.request.urlopen(req, timeout=90) as r:
+        raw = r.read()
+        return json.loads(raw) if raw else {}
+
+
+def to_snow_time(v):
+    """Normalize ISO8601 / epoch (s or ms) / native format to 'YYYY-MM-DD HH:MM:SS' UTC."""
+    s = str(v or "").strip()
+    if not s:
+        return None
+    if s.isdigit():
+        ts = int(s)
+        if ts > 10**12:
+            ts //= 1000
+        return datetime.fromtimestamp(ts, tz=timezone.utc).strftime("%Y-%m-%d %H:%M:%S")
+    if len(s) == 19 and s[4] == "-" and s[10] == " ":
+        return s
+    try:
+        dt = datetime.fromisoformat(s.replace("Z", "+00:00"))
+        if dt.tzinfo is not None:
+            dt = dt.astimezone(timezone.utc)
+        return dt.strftime("%Y-%m-%d %H:%M:%S")
+    except Exception:
+        return s
+
+
+def main():
+    cfg = _cfg()
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    table = str(inputs.get("ticket_type") or cfg.get("ticket_type") or "incident")
+    ts_field = str(cfg.get("timestamp_field") or "opened_at")
+    limit = int(inputs.get("limit") or 100)
+
+    parts = []
+    if inputs.get("query"):
+        parts.append(str(inputs["query"]))
+    watermark = to_snow_time(inputs.get("created_after"))
+    if watermark:
+        parts.append(ts_field + ">" + watermark)
+    parts.append("ORDERBY" + ts_field)
+
+    print(json.dumps(request("GET", "/table/" + urllib.parse.quote(table), params={
+        "sysparm_query": "^".join(parts),
+        "sysparm_limit": limit,
+    })))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/servicenow/scripts/get_item_details.py

@@ -0,0 +1,60 @@
+import base64, json, os, sys, urllib.parse, urllib.request, urllib.error
+
+
+def _cfg():
+    return json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+
+
+def _headers(cfg):
+    h = {"Accept": "application/json", "Content-Type": "application/json"}
+    if str(cfg.get("auth_type") or "basic").lower() == "oauth":
+        data = urllib.parse.urlencode({
+            "grant_type": "password",
+            "client_id": cfg.get("client_id", ""),
+            "client_secret": cfg.get("client_secret", ""),
+            "username": cfg.get("username", ""),
+            "password": cfg.get("password", ""),
+        }).encode("utf-8")
+        req = urllib.request.Request(
+            cfg.get("url", "").rstrip("/") + "/oauth_token.do", data=data,
+            headers={"Content-Type": "application/x-www-form-urlencoded", "Accept": "application/json"}, method="POST")
+        with urllib.request.urlopen(req, timeout=60) as r:
+            tok = json.loads(r.read())
+        if not tok.get("access_token"):
+            raise Exception("OAuth token request failed: " + json.dumps(tok))
+        h["Authorization"] = "Bearer " + tok["access_token"]
+    else:
+        cred = (cfg.get("username", "") + ":" + cfg.get("password", "")).encode("utf-8")
+        h["Authorization"] = "Basic " + base64.b64encode(cred).decode("ascii")
+    return h
+
+
+def request(method, path, params=None, body=None, root="/api/now", versioned=True):
+    cfg = _cfg()
+    v = str(cfg.get("api_version") or "").strip().strip("/")
+    url = cfg.get("url", "").rstrip("/") + root + ("/" + v if v and versioned else "") + path
+    q = {k: str(x) for k, x in (params or {}).items() if x not in (None, "")}
+    if q:
+        url += "?" + urllib.parse.urlencode(q)
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=_headers(cfg), method=method)
+    with urllib.request.urlopen(req, timeout=90) as r:
+        raw = r.read()
+        return json.loads(raw) if raw else {}
+
+
+def main():
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    iid = inputs.get("id") or ""
+    res = request("GET", "/servicecatalog/items/" + urllib.parse.quote(iid), root="/api/sn_sc")
+    print(json.dumps(res))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/servicenow/scripts/get_record.py

@@ -0,0 +1,67 @@
+import base64, json, os, sys, urllib.parse, urllib.request, urllib.error
+
+
+def _cfg():
+    return json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+
+
+def _headers(cfg):
+    h = {"Accept": "application/json", "Content-Type": "application/json"}
+    if str(cfg.get("auth_type") or "basic").lower() == "oauth":
+        data = urllib.parse.urlencode({
+            "grant_type": "password",
+            "client_id": cfg.get("client_id", ""),
+            "client_secret": cfg.get("client_secret", ""),
+            "username": cfg.get("username", ""),
+            "password": cfg.get("password", ""),
+        }).encode("utf-8")
+        req = urllib.request.Request(
+            cfg.get("url", "").rstrip("/") + "/oauth_token.do", data=data,
+            headers={"Content-Type": "application/x-www-form-urlencoded", "Accept": "application/json"}, method="POST")
+        with urllib.request.urlopen(req, timeout=60) as r:
+            tok = json.loads(r.read())
+        if not tok.get("access_token"):
+            raise Exception("OAuth token request failed: " + json.dumps(tok))
+        h["Authorization"] = "Bearer " + tok["access_token"]
+    else:
+        cred = (cfg.get("username", "") + ":" + cfg.get("password", "")).encode("utf-8")
+        h["Authorization"] = "Basic " + base64.b64encode(cred).decode("ascii")
+    return h
+
+
+def request(method, path, params=None, body=None, root="/api/now", versioned=True):
+    cfg = _cfg()
+    v = str(cfg.get("api_version") or "").strip().strip("/")
+    url = cfg.get("url", "").rstrip("/") + root + ("/" + v if v and versioned else "") + path
+    q = {k: str(x) for k, x in (params or {}).items() if x not in (None, "")}
+    if q:
+        url += "?" + urllib.parse.urlencode(q)
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=_headers(cfg), method=method)
+    with urllib.request.urlopen(req, timeout=90) as r:
+        raw = r.read()
+        return json.loads(raw) if raw else {}
+
+
+def main():
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    table = inputs.get("table_name") or ""
+    rid = inputs.get("id") or ""
+    fields = str(inputs.get("fields") or "").strip()
+    if fields and "sys_id" not in [x.strip() for x in fields.split(",")]:
+        fields += ",sys_id"
+    res = request("GET", "/table/" + urllib.parse.quote(table) + "/" + urllib.parse.quote(rid), params={
+        "sysparm_fields": fields or None,
+        "sysparm_display_value": inputs.get("display_value"),
+    })
+    print(json.dumps(res))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/servicenow/scripts/get_table_name.py

@@ -0,0 +1,64 @@
+import base64, json, os, sys, urllib.parse, urllib.request, urllib.error
+
+
+def _cfg():
+    return json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+
+
+def _headers(cfg):
+    h = {"Accept": "application/json", "Content-Type": "application/json"}
+    if str(cfg.get("auth_type") or "basic").lower() == "oauth":
+        data = urllib.parse.urlencode({
+            "grant_type": "password",
+            "client_id": cfg.get("client_id", ""),
+            "client_secret": cfg.get("client_secret", ""),
+            "username": cfg.get("username", ""),
+            "password": cfg.get("password", ""),
+        }).encode("utf-8")
+        req = urllib.request.Request(
+            cfg.get("url", "").rstrip("/") + "/oauth_token.do", data=data,
+            headers={"Content-Type": "application/x-www-form-urlencoded", "Accept": "application/json"}, method="POST")
+        with urllib.request.urlopen(req, timeout=60) as r:
+            tok = json.loads(r.read())
+        if not tok.get("access_token"):
+            raise Exception("OAuth token request failed: " + json.dumps(tok))
+        h["Authorization"] = "Bearer " + tok["access_token"]
+    else:
+        cred = (cfg.get("username", "") + ":" + cfg.get("password", "")).encode("utf-8")
+        h["Authorization"] = "Basic " + base64.b64encode(cred).decode("ascii")
+    return h
+
+
+def request(method, path, params=None, body=None, root="/api/now", versioned=True):
+    cfg = _cfg()
+    v = str(cfg.get("api_version") or "").strip().strip("/")
+    url = cfg.get("url", "").rstrip("/") + root + ("/" + v if v and versioned else "") + path
+    q = {k: str(x) for k, x in (params or {}).items() if x not in (None, "")}
+    if q:
+        url += "?" + urllib.parse.urlencode(q)
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=_headers(cfg), method=method)
+    with urllib.request.urlopen(req, timeout=90) as r:
+        raw = r.read()
+        return json.loads(raw) if raw else {}
+
+
+def main():
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    label = inputs.get("label") or ""
+    res = request("GET", "/table/sys_db_object", params={
+        "sysparm_query": "label=" + label,
+        "sysparm_limit": inputs.get("limit") or 10,
+        "sysparm_fields": "sys_id,name,label,sys_name",
+    })
+    print(json.dumps(res))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/servicenow/scripts/get_ticket.py

@@ -0,0 +1,74 @@
+import base64, json, os, sys, urllib.parse, urllib.request, urllib.error
+
+
+def _cfg():
+    return json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+
+
+def _headers(cfg):
+    h = {"Accept": "application/json", "Content-Type": "application/json"}
+    if str(cfg.get("auth_type") or "basic").lower() == "oauth":
+        data = urllib.parse.urlencode({
+            "grant_type": "password",
+            "client_id": cfg.get("client_id", ""),
+            "client_secret": cfg.get("client_secret", ""),
+            "username": cfg.get("username", ""),
+            "password": cfg.get("password", ""),
+        }).encode("utf-8")
+        req = urllib.request.Request(
+            cfg.get("url", "").rstrip("/") + "/oauth_token.do", data=data,
+            headers={"Content-Type": "application/x-www-form-urlencoded", "Accept": "application/json"}, method="POST")
+        with urllib.request.urlopen(req, timeout=60) as r:
+            tok = json.loads(r.read())
+        if not tok.get("access_token"):
+            raise Exception("OAuth token request failed: " + json.dumps(tok))
+        h["Authorization"] = "Bearer " + tok["access_token"]
+    else:
+        cred = (cfg.get("username", "") + ":" + cfg.get("password", "")).encode("utf-8")
+        h["Authorization"] = "Basic " + base64.b64encode(cred).decode("ascii")
+    return h
+
+
+def request(method, path, params=None, body=None, root="/api/now", versioned=True):
+    cfg = _cfg()
+    v = str(cfg.get("api_version") or "").strip().strip("/")
+    url = cfg.get("url", "").rstrip("/") + root + ("/" + v if v and versioned else "") + path
+    q = {k: str(x) for k, x in (params or {}).items() if x not in (None, "")}
+    if q:
+        url += "?" + urllib.parse.urlencode(q)
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=_headers(cfg), method=method)
+    with urllib.request.urlopen(req, timeout=90) as r:
+        raw = r.read()
+        return json.loads(raw) if raw else {}
+
+
+def main():
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    table = str(inputs.get("ticket_type") or _cfg().get("ticket_type") or "incident")
+    fields = str(inputs.get("fields") or "")
+    if fields and "sys_id" not in fields:
+        fields += ",sys_id"
+    params = {
+        "sysparm_fields": fields or None,
+        "sysparm_display_value": inputs.get("display_value"),
+    }
+    if inputs.get("id"):
+        res = request("GET", "/table/" + urllib.parse.quote(table) + "/" + urllib.parse.quote(str(inputs["id"])), params=params)
+    elif inputs.get("number"):
+        params["sysparm_query"] = "number=" + str(inputs["number"])
+        params["sysparm_limit"] = 1
+        res = request("GET", "/table/" + urllib.parse.quote(table), params=params)
+    else:
+        raise Exception("id or number is required")
+    print(json.dumps(res))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/servicenow/scripts/get_ticket_attachments.py

@@ -0,0 +1,62 @@
+import base64, json, os, sys, urllib.parse, urllib.request, urllib.error
+
+
+def _cfg():
+    return json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+
+
+def _headers(cfg):
+    h = {"Accept": "application/json", "Content-Type": "application/json"}
+    if str(cfg.get("auth_type") or "basic").lower() == "oauth":
+        data = urllib.parse.urlencode({
+            "grant_type": "password",
+            "client_id": cfg.get("client_id", ""),
+            "client_secret": cfg.get("client_secret", ""),
+            "username": cfg.get("username", ""),
+            "password": cfg.get("password", ""),
+        }).encode("utf-8")
+        req = urllib.request.Request(
+            cfg.get("url", "").rstrip("/") + "/oauth_token.do", data=data,
+            headers={"Content-Type": "application/x-www-form-urlencoded", "Accept": "application/json"}, method="POST")
+        with urllib.request.urlopen(req, timeout=60) as r:
+            tok = json.loads(r.read())
+        if not tok.get("access_token"):
+            raise Exception("OAuth token request failed: " + json.dumps(tok))
+        h["Authorization"] = "Bearer " + tok["access_token"]
+    else:
+        cred = (cfg.get("username", "") + ":" + cfg.get("password", "")).encode("utf-8")
+        h["Authorization"] = "Basic " + base64.b64encode(cred).decode("ascii")
+    return h
+
+
+def request(method, path, params=None, body=None, root="/api/now", versioned=True):
+    cfg = _cfg()
+    v = str(cfg.get("api_version") or "").strip().strip("/")
+    url = cfg.get("url", "").rstrip("/") + root + ("/" + v if v and versioned else "") + path
+    q = {k: str(x) for k, x in (params or {}).items() if x not in (None, "")}
+    if q:
+        url += "?" + urllib.parse.urlencode(q)
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=_headers(cfg), method=method)
+    with urllib.request.urlopen(req, timeout=90) as r:
+        raw = r.read()
+        return json.loads(raw) if raw else {}
+
+
+def main():
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    ticket_id = str(inputs.get("id") or "")
+    if not ticket_id:
+        raise Exception("id is required")
+    params = {"sysparm_query": "table_sys_id=" + ticket_id}
+    print(json.dumps(request("GET", "/attachment", params=params, versioned=False)))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/servicenow/scripts/get_ticket_notes.py

@@ -0,0 +1,66 @@
+import base64, json, os, sys, urllib.parse, urllib.request, urllib.error
+
+
+def _cfg():
+    return json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+
+
+def _headers(cfg):
+    h = {"Accept": "application/json", "Content-Type": "application/json"}
+    if str(cfg.get("auth_type") or "basic").lower() == "oauth":
+        data = urllib.parse.urlencode({
+            "grant_type": "password",
+            "client_id": cfg.get("client_id", ""),
+            "client_secret": cfg.get("client_secret", ""),
+            "username": cfg.get("username", ""),
+            "password": cfg.get("password", ""),
+        }).encode("utf-8")
+        req = urllib.request.Request(
+            cfg.get("url", "").rstrip("/") + "/oauth_token.do", data=data,
+            headers={"Content-Type": "application/x-www-form-urlencoded", "Accept": "application/json"}, method="POST")
+        with urllib.request.urlopen(req, timeout=60) as r:
+            tok = json.loads(r.read())
+        if not tok.get("access_token"):
+            raise Exception("OAuth token request failed: " + json.dumps(tok))
+        h["Authorization"] = "Bearer " + tok["access_token"]
+    else:
+        cred = (cfg.get("username", "") + ":" + cfg.get("password", "")).encode("utf-8")
+        h["Authorization"] = "Basic " + base64.b64encode(cred).decode("ascii")
+    return h
+
+
+def request(method, path, params=None, body=None, root="/api/now", versioned=True):
+    cfg = _cfg()
+    v = str(cfg.get("api_version") or "").strip().strip("/")
+    url = cfg.get("url", "").rstrip("/") + root + ("/" + v if v and versioned else "") + path
+    q = {k: str(x) for k, x in (params or {}).items() if x not in (None, "")}
+    if q:
+        url += "?" + urllib.parse.urlencode(q)
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=_headers(cfg), method=method)
+    with urllib.request.urlopen(req, timeout=90) as r:
+        raw = r.read()
+        return json.loads(raw) if raw else {}
+
+
+def main():
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    ticket_id = str(inputs.get("id") or "")
+    if not ticket_id:
+        raise Exception("id is required")
+    params = {
+        "sysparm_query": "element_id=" + ticket_id + "^element=comments^ORelement=work_notes^ORDERBYsys_created_on",
+        "sysparm_limit": inputs.get("limit") or 10,
+        "sysparm_offset": inputs.get("offset") or 0,
+    }
+    print(json.dumps(request("GET", "/table/sys_journal_field", params=params)))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/servicenow/scripts/list_table_fields.py

@@ -0,0 +1,64 @@
+import base64, json, os, sys, urllib.parse, urllib.request, urllib.error
+
+
+def _cfg():
+    return json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+
+
+def _headers(cfg):
+    h = {"Accept": "application/json", "Content-Type": "application/json"}
+    if str(cfg.get("auth_type") or "basic").lower() == "oauth":
+        data = urllib.parse.urlencode({
+            "grant_type": "password",
+            "client_id": cfg.get("client_id", ""),
+            "client_secret": cfg.get("client_secret", ""),
+            "username": cfg.get("username", ""),
+            "password": cfg.get("password", ""),
+        }).encode("utf-8")
+        req = urllib.request.Request(
+            cfg.get("url", "").rstrip("/") + "/oauth_token.do", data=data,
+            headers={"Content-Type": "application/x-www-form-urlencoded", "Accept": "application/json"}, method="POST")
+        with urllib.request.urlopen(req, timeout=60) as r:
+            tok = json.loads(r.read())
+        if not tok.get("access_token"):
+            raise Exception("OAuth token request failed: " + json.dumps(tok))
+        h["Authorization"] = "Bearer " + tok["access_token"]
+    else:
+        cred = (cfg.get("username", "") + ":" + cfg.get("password", "")).encode("utf-8")
+        h["Authorization"] = "Basic " + base64.b64encode(cred).decode("ascii")
+    return h
+
+
+def request(method, path, params=None, body=None, root="/api/now", versioned=True):
+    cfg = _cfg()
+    v = str(cfg.get("api_version") or "").strip().strip("/")
+    url = cfg.get("url", "").rstrip("/") + root + ("/" + v if v and versioned else "") + path
+    q = {k: str(x) for k, x in (params or {}).items() if x not in (None, "")}
+    if q:
+        url += "?" + urllib.parse.urlencode(q)
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=_headers(cfg), method=method)
+    with urllib.request.urlopen(req, timeout=90) as r:
+        raw = r.read()
+        return json.loads(raw) if raw else {}
+
+
+def main():
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    table = inputs.get("table_name") or ""
+    res = request("GET", "/table/" + urllib.parse.quote(table), params={"sysparm_limit": 1})
+    rows = res.get("result") or []
+    if not rows:
+        print(json.dumps({"table": table, "fields": []}))
+        return
+    print(json.dumps({"table": table, "fields": sorted(rows[0].keys())}))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/servicenow/scripts/query_computers.py

@@ -0,0 +1,73 @@
+import base64, json, os, sys, urllib.parse, urllib.request, urllib.error
+
+
+def _cfg():
+    return json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+
+
+def _headers(cfg):
+    h = {"Accept": "application/json", "Content-Type": "application/json"}
+    if str(cfg.get("auth_type") or "basic").lower() == "oauth":
+        data = urllib.parse.urlencode({
+            "grant_type": "password",
+            "client_id": cfg.get("client_id", ""),
+            "client_secret": cfg.get("client_secret", ""),
+            "username": cfg.get("username", ""),
+            "password": cfg.get("password", ""),
+        }).encode("utf-8")
+        req = urllib.request.Request(
+            cfg.get("url", "").rstrip("/") + "/oauth_token.do", data=data,
+            headers={"Content-Type": "application/x-www-form-urlencoded", "Accept": "application/json"}, method="POST")
+        with urllib.request.urlopen(req, timeout=60) as r:
+            tok = json.loads(r.read())
+        if not tok.get("access_token"):
+            raise Exception("OAuth token request failed: " + json.dumps(tok))
+        h["Authorization"] = "Bearer " + tok["access_token"]
+    else:
+        cred = (cfg.get("username", "") + ":" + cfg.get("password", "")).encode("utf-8")
+        h["Authorization"] = "Basic " + base64.b64encode(cred).decode("ascii")
+    return h
+
+
+def request(method, path, params=None, body=None, root="/api/now", versioned=True):
+    cfg = _cfg()
+    v = str(cfg.get("api_version") or "").strip().strip("/")
+    url = cfg.get("url", "").rstrip("/") + root + ("/" + v if v and versioned else "") + path
+    q = {k: str(x) for k, x in (params or {}).items() if x not in (None, "")}
+    if q:
+        url += "?" + urllib.parse.urlencode(q)
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=_headers(cfg), method=method)
+    with urllib.request.urlopen(req, timeout=90) as r:
+        raw = r.read()
+        return json.loads(raw) if raw else {}
+
+
+def main():
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    cid = inputs.get("computer_id") or ""
+    if cid:
+        res = request("GET", "/table/cmdb_ci_computer/" + urllib.parse.quote(cid))
+    else:
+        if inputs.get("computer_name"):
+            q = "name=" + inputs["computer_name"]
+        elif inputs.get("asset_tag"):
+            q = "asset_tag=" + inputs["asset_tag"]
+        else:
+            q = inputs.get("query") or ""
+        res = request("GET", "/table/cmdb_ci_computer", params={
+            "sysparm_query": q,
+            "sysparm_limit": inputs.get("limit") or 10,
+            "sysparm_offset": inputs.get("offset") or 0,
+        })
+    print(json.dumps(res))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/servicenow/scripts/query_groups.py

@@ -0,0 +1,71 @@
+import base64, json, os, sys, urllib.parse, urllib.request, urllib.error
+
+
+def _cfg():
+    return json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+
+
+def _headers(cfg):
+    h = {"Accept": "application/json", "Content-Type": "application/json"}
+    if str(cfg.get("auth_type") or "basic").lower() == "oauth":
+        data = urllib.parse.urlencode({
+            "grant_type": "password",
+            "client_id": cfg.get("client_id", ""),
+            "client_secret": cfg.get("client_secret", ""),
+            "username": cfg.get("username", ""),
+            "password": cfg.get("password", ""),
+        }).encode("utf-8")
+        req = urllib.request.Request(
+            cfg.get("url", "").rstrip("/") + "/oauth_token.do", data=data,
+            headers={"Content-Type": "application/x-www-form-urlencoded", "Accept": "application/json"}, method="POST")
+        with urllib.request.urlopen(req, timeout=60) as r:
+            tok = json.loads(r.read())
+        if not tok.get("access_token"):
+            raise Exception("OAuth token request failed: " + json.dumps(tok))
+        h["Authorization"] = "Bearer " + tok["access_token"]
+    else:
+        cred = (cfg.get("username", "") + ":" + cfg.get("password", "")).encode("utf-8")
+        h["Authorization"] = "Basic " + base64.b64encode(cred).decode("ascii")
+    return h
+
+
+def request(method, path, params=None, body=None, root="/api/now", versioned=True):
+    cfg = _cfg()
+    v = str(cfg.get("api_version") or "").strip().strip("/")
+    url = cfg.get("url", "").rstrip("/") + root + ("/" + v if v and versioned else "") + path
+    q = {k: str(x) for k, x in (params or {}).items() if x not in (None, "")}
+    if q:
+        url += "?" + urllib.parse.urlencode(q)
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=_headers(cfg), method=method)
+    with urllib.request.urlopen(req, timeout=90) as r:
+        raw = r.read()
+        return json.loads(raw) if raw else {}
+
+
+def main():
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    gid = inputs.get("group_id") or ""
+    if gid:
+        res = request("GET", "/table/sys_user_group/" + urllib.parse.quote(gid))
+    else:
+        if inputs.get("group_name"):
+            q = "name=" + inputs["group_name"]
+        else:
+            q = inputs.get("query") or ""
+        res = request("GET", "/table/sys_user_group", params={
+            "sysparm_query": q,
+            "sysparm_limit": inputs.get("limit") or 10,
+            "sysparm_offset": inputs.get("offset") or 0,
+        })
+    print(json.dumps(res))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/servicenow/scripts/query_items.py

@@ -0,0 +1,63 @@
+import base64, json, os, sys, urllib.parse, urllib.request, urllib.error
+
+
+def _cfg():
+    return json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+
+
+def _headers(cfg):
+    h = {"Accept": "application/json", "Content-Type": "application/json"}
+    if str(cfg.get("auth_type") or "basic").lower() == "oauth":
+        data = urllib.parse.urlencode({
+            "grant_type": "password",
+            "client_id": cfg.get("client_id", ""),
+            "client_secret": cfg.get("client_secret", ""),
+            "username": cfg.get("username", ""),
+            "password": cfg.get("password", ""),
+        }).encode("utf-8")
+        req = urllib.request.Request(
+            cfg.get("url", "").rstrip("/") + "/oauth_token.do", data=data,
+            headers={"Content-Type": "application/x-www-form-urlencoded", "Accept": "application/json"}, method="POST")
+        with urllib.request.urlopen(req, timeout=60) as r:
+            tok = json.loads(r.read())
+        if not tok.get("access_token"):
+            raise Exception("OAuth token request failed: " + json.dumps(tok))
+        h["Authorization"] = "Bearer " + tok["access_token"]
+    else:
+        cred = (cfg.get("username", "") + ":" + cfg.get("password", "")).encode("utf-8")
+        h["Authorization"] = "Basic " + base64.b64encode(cred).decode("ascii")
+    return h
+
+
+def request(method, path, params=None, body=None, root="/api/now", versioned=True):
+    cfg = _cfg()
+    v = str(cfg.get("api_version") or "").strip().strip("/")
+    url = cfg.get("url", "").rstrip("/") + root + ("/" + v if v and versioned else "") + path
+    q = {k: str(x) for k, x in (params or {}).items() if x not in (None, "")}
+    if q:
+        url += "?" + urllib.parse.urlencode(q)
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=_headers(cfg), method=method)
+    with urllib.request.urlopen(req, timeout=90) as r:
+        raw = r.read()
+        return json.loads(raw) if raw else {}
+
+
+def main():
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    res = request("GET", "/servicecatalog/items", root="/api/sn_sc", params={
+        "sysparm_text": inputs.get("name"),
+        "sysparm_limit": inputs.get("limit") or 10,
+        "sysparm_offset": inputs.get("offset") or 0,
+    })
+    print(json.dumps(res))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/servicenow/scripts/query_table.py

@@ -0,0 +1,69 @@
+import base64, json, os, sys, urllib.parse, urllib.request, urllib.error
+
+
+def _cfg():
+    return json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+
+
+def _headers(cfg):
+    h = {"Accept": "application/json", "Content-Type": "application/json"}
+    if str(cfg.get("auth_type") or "basic").lower() == "oauth":
+        data = urllib.parse.urlencode({
+            "grant_type": "password",
+            "client_id": cfg.get("client_id", ""),
+            "client_secret": cfg.get("client_secret", ""),
+            "username": cfg.get("username", ""),
+            "password": cfg.get("password", ""),
+        }).encode("utf-8")
+        req = urllib.request.Request(
+            cfg.get("url", "").rstrip("/") + "/oauth_token.do", data=data,
+            headers={"Content-Type": "application/x-www-form-urlencoded", "Accept": "application/json"}, method="POST")
+        with urllib.request.urlopen(req, timeout=60) as r:
+            tok = json.loads(r.read())
+        if not tok.get("access_token"):
+            raise Exception("OAuth token request failed: " + json.dumps(tok))
+        h["Authorization"] = "Bearer " + tok["access_token"]
+    else:
+        cred = (cfg.get("username", "") + ":" + cfg.get("password", "")).encode("utf-8")
+        h["Authorization"] = "Basic " + base64.b64encode(cred).decode("ascii")
+    return h
+
+
+def request(method, path, params=None, body=None, root="/api/now", versioned=True):
+    cfg = _cfg()
+    v = str(cfg.get("api_version") or "").strip().strip("/")
+    url = cfg.get("url", "").rstrip("/") + root + ("/" + v if v and versioned else "") + path
+    q = {k: str(x) for k, x in (params or {}).items() if x not in (None, "")}
+    if q:
+        url += "?" + urllib.parse.urlencode(q)
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=_headers(cfg), method=method)
+    with urllib.request.urlopen(req, timeout=90) as r:
+        raw = r.read()
+        return json.loads(raw) if raw else {}
+
+
+def main():
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    table = inputs.get("table_name") or ""
+    fields = str(inputs.get("fields") or "").strip()
+    if fields and "sys_id" not in [x.strip() for x in fields.split(",")]:
+        fields += ",sys_id"
+    res = request("GET", "/table/" + urllib.parse.quote(table), params={
+        "sysparm_query": inputs.get("query"),
+        "sysparm_limit": inputs.get("limit") or 10,
+        "sysparm_offset": inputs.get("offset") or 0,
+        "sysparm_fields": fields or None,
+        "sysparm_display_value": inputs.get("display_value"),
+    })
+    print(json.dumps(res))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/servicenow/scripts/query_tickets.py

@@ -0,0 +1,69 @@
+import base64, json, os, sys, urllib.parse, urllib.request, urllib.error
+
+
+def _cfg():
+    return json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+
+
+def _headers(cfg):
+    h = {"Accept": "application/json", "Content-Type": "application/json"}
+    if str(cfg.get("auth_type") or "basic").lower() == "oauth":
+        data = urllib.parse.urlencode({
+            "grant_type": "password",
+            "client_id": cfg.get("client_id", ""),
+            "client_secret": cfg.get("client_secret", ""),
+            "username": cfg.get("username", ""),
+            "password": cfg.get("password", ""),
+        }).encode("utf-8")
+        req = urllib.request.Request(
+            cfg.get("url", "").rstrip("/") + "/oauth_token.do", data=data,
+            headers={"Content-Type": "application/x-www-form-urlencoded", "Accept": "application/json"}, method="POST")
+        with urllib.request.urlopen(req, timeout=60) as r:
+            tok = json.loads(r.read())
+        if not tok.get("access_token"):
+            raise Exception("OAuth token request failed: " + json.dumps(tok))
+        h["Authorization"] = "Bearer " + tok["access_token"]
+    else:
+        cred = (cfg.get("username", "") + ":" + cfg.get("password", "")).encode("utf-8")
+        h["Authorization"] = "Basic " + base64.b64encode(cred).decode("ascii")
+    return h
+
+
+def request(method, path, params=None, body=None, root="/api/now", versioned=True):
+    cfg = _cfg()
+    v = str(cfg.get("api_version") or "").strip().strip("/")
+    url = cfg.get("url", "").rstrip("/") + root + ("/" + v if v and versioned else "") + path
+    q = {k: str(x) for k, x in (params or {}).items() if x not in (None, "")}
+    if q:
+        url += "?" + urllib.parse.urlencode(q)
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=_headers(cfg), method=method)
+    with urllib.request.urlopen(req, timeout=90) as r:
+        raw = r.read()
+        return json.loads(raw) if raw else {}
+
+
+def main():
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    table = str(inputs.get("ticket_type") or _cfg().get("ticket_type") or "incident")
+    fields = str(inputs.get("fields") or "")
+    if fields and "sys_id" not in fields:
+        fields += ",sys_id"
+    params = {
+        "sysparm_query": inputs.get("query"),
+        "sysparm_limit": inputs.get("limit") or 10,
+        "sysparm_offset": inputs.get("offset") or 0,
+        "sysparm_fields": fields or None,
+        "sysparm_display_value": inputs.get("display_value"),
+    }
+    print(json.dumps(request("GET", "/table/" + urllib.parse.quote(table), params=params)))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/servicenow/scripts/query_users.py

@@ -0,0 +1,71 @@
+import base64, json, os, sys, urllib.parse, urllib.request, urllib.error
+
+
+def _cfg():
+    return json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+
+
+def _headers(cfg):
+    h = {"Accept": "application/json", "Content-Type": "application/json"}
+    if str(cfg.get("auth_type") or "basic").lower() == "oauth":
+        data = urllib.parse.urlencode({
+            "grant_type": "password",
+            "client_id": cfg.get("client_id", ""),
+            "client_secret": cfg.get("client_secret", ""),
+            "username": cfg.get("username", ""),
+            "password": cfg.get("password", ""),
+        }).encode("utf-8")
+        req = urllib.request.Request(
+            cfg.get("url", "").rstrip("/") + "/oauth_token.do", data=data,
+            headers={"Content-Type": "application/x-www-form-urlencoded", "Accept": "application/json"}, method="POST")
+        with urllib.request.urlopen(req, timeout=60) as r:
+            tok = json.loads(r.read())
+        if not tok.get("access_token"):
+            raise Exception("OAuth token request failed: " + json.dumps(tok))
+        h["Authorization"] = "Bearer " + tok["access_token"]
+    else:
+        cred = (cfg.get("username", "") + ":" + cfg.get("password", "")).encode("utf-8")
+        h["Authorization"] = "Basic " + base64.b64encode(cred).decode("ascii")
+    return h
+
+
+def request(method, path, params=None, body=None, root="/api/now", versioned=True):
+    cfg = _cfg()
+    v = str(cfg.get("api_version") or "").strip().strip("/")
+    url = cfg.get("url", "").rstrip("/") + root + ("/" + v if v and versioned else "") + path
+    q = {k: str(x) for k, x in (params or {}).items() if x not in (None, "")}
+    if q:
+        url += "?" + urllib.parse.urlencode(q)
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=_headers(cfg), method=method)
+    with urllib.request.urlopen(req, timeout=90) as r:
+        raw = r.read()
+        return json.loads(raw) if raw else {}
+
+
+def main():
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    uid = inputs.get("user_id") or ""
+    if uid:
+        res = request("GET", "/table/sys_user/" + urllib.parse.quote(uid))
+    else:
+        if inputs.get("user_name"):
+            q = "user_name=" + inputs["user_name"]
+        else:
+            q = inputs.get("query") or ""
+        res = request("GET", "/table/sys_user", params={
+            "sysparm_query": q,
+            "sysparm_limit": inputs.get("limit") or 10,
+            "sysparm_offset": inputs.get("offset") or 0,
+        })
+    print(json.dumps(res))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/servicenow/scripts/test_connection.py

@@ -0,0 +1,62 @@
+import base64, json, os, sys, urllib.parse, urllib.request, urllib.error
+
+
+def _cfg():
+    return json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+
+
+def _headers(cfg):
+    h = {"Accept": "application/json", "Content-Type": "application/json"}
+    if str(cfg.get("auth_type") or "basic").lower() == "oauth":
+        data = urllib.parse.urlencode({
+            "grant_type": "password",
+            "client_id": cfg.get("client_id", ""),
+            "client_secret": cfg.get("client_secret", ""),
+            "username": cfg.get("username", ""),
+            "password": cfg.get("password", ""),
+        }).encode("utf-8")
+        req = urllib.request.Request(
+            cfg.get("url", "").rstrip("/") + "/oauth_token.do", data=data,
+            headers={"Content-Type": "application/x-www-form-urlencoded", "Accept": "application/json"}, method="POST")
+        with urllib.request.urlopen(req, timeout=60) as r:
+            tok = json.loads(r.read())
+        if not tok.get("access_token"):
+            raise Exception("OAuth token request failed: " + json.dumps(tok))
+        h["Authorization"] = "Bearer " + tok["access_token"]
+    else:
+        cred = (cfg.get("username", "") + ":" + cfg.get("password", "")).encode("utf-8")
+        h["Authorization"] = "Basic " + base64.b64encode(cred).decode("ascii")
+    return h
+
+
+def request(method, path, params=None, body=None, root="/api/now", versioned=True):
+    cfg = _cfg()
+    v = str(cfg.get("api_version") or "").strip().strip("/")
+    url = cfg.get("url", "").rstrip("/") + root + ("/" + v if v and versioned else "") + path
+    q = {k: str(x) for k, x in (params or {}).items() if x not in (None, "")}
+    if q:
+        url += "?" + urllib.parse.urlencode(q)
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=_headers(cfg), method=method)
+    with urllib.request.urlopen(req, timeout=90) as r:
+        raw = r.read()
+        return json.loads(raw) if raw else {}
+
+
+def main():
+    cfg = _cfg()
+    table = str(cfg.get("ticket_type") or "incident")
+    res = request("GET", "/table/" + urllib.parse.quote(table), params={"sysparm_limit": 1})
+    if "result" not in res:
+        raise Exception("Unexpected response: " + json.dumps(res))
+    print(json.dumps({"ok": True, "table": table}))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/servicenow/scripts/update_record.py

@@ -0,0 +1,80 @@
+import base64, json, os, sys, urllib.parse, urllib.request, urllib.error
+
+
+def _cfg():
+    return json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+
+
+def _headers(cfg):
+    h = {"Accept": "application/json", "Content-Type": "application/json"}
+    if str(cfg.get("auth_type") or "basic").lower() == "oauth":
+        data = urllib.parse.urlencode({
+            "grant_type": "password",
+            "client_id": cfg.get("client_id", ""),
+            "client_secret": cfg.get("client_secret", ""),
+            "username": cfg.get("username", ""),
+            "password": cfg.get("password", ""),
+        }).encode("utf-8")
+        req = urllib.request.Request(
+            cfg.get("url", "").rstrip("/") + "/oauth_token.do", data=data,
+            headers={"Content-Type": "application/x-www-form-urlencoded", "Accept": "application/json"}, method="POST")
+        with urllib.request.urlopen(req, timeout=60) as r:
+            tok = json.loads(r.read())
+        if not tok.get("access_token"):
+            raise Exception("OAuth token request failed: " + json.dumps(tok))
+        h["Authorization"] = "Bearer " + tok["access_token"]
+    else:
+        cred = (cfg.get("username", "") + ":" + cfg.get("password", "")).encode("utf-8")
+        h["Authorization"] = "Basic " + base64.b64encode(cred).decode("ascii")
+    return h
+
+
+def request(method, path, params=None, body=None, root="/api/now", versioned=True):
+    cfg = _cfg()
+    v = str(cfg.get("api_version") or "").strip().strip("/")
+    url = cfg.get("url", "").rstrip("/") + root + ("/" + v if v and versioned else "") + path
+    q = {k: str(x) for k, x in (params or {}).items() if x not in (None, "")}
+    if q:
+        url += "?" + urllib.parse.urlencode(q)
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=_headers(cfg), method=method)
+    with urllib.request.urlopen(req, timeout=90) as r:
+        raw = r.read()
+        return json.loads(raw) if raw else {}
+
+
+def split_fields(s, prefix_custom=False):
+    out = {}
+    for part in str(s or "").split(";"):
+        if "=" not in part:
+            continue
+        k, v = part.split("=", 1)
+        k = k.strip()
+        if prefix_custom and k and not k.startswith("u_"):
+            k = "u_" + k
+        if k:
+            out[k] = v
+    return out
+
+
+def main():
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    table = inputs.get("table_name") or ""
+    rid = inputs.get("id") or ""
+    body = split_fields(inputs.get("fields"))
+    body.update(split_fields(inputs.get("custom_fields"), prefix_custom=True))
+    if not body:
+        raise Exception("nothing to update")
+    params = {"sysparm_input_display_value": "true"} if inputs.get("input_display_value") else None
+    res = request("PATCH", "/table/" + urllib.parse.quote(table) + "/" + urllib.parse.quote(rid), params=params, body=body)
+    print(json.dumps(res))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/servicenow/scripts/update_ticket.py

@@ -0,0 +1,93 @@
+import base64, json, os, sys, urllib.parse, urllib.request, urllib.error
+
+
+def _cfg():
+    return json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+
+
+def _headers(cfg):
+    h = {"Accept": "application/json", "Content-Type": "application/json"}
+    if str(cfg.get("auth_type") or "basic").lower() == "oauth":
+        data = urllib.parse.urlencode({
+            "grant_type": "password",
+            "client_id": cfg.get("client_id", ""),
+            "client_secret": cfg.get("client_secret", ""),
+            "username": cfg.get("username", ""),
+            "password": cfg.get("password", ""),
+        }).encode("utf-8")
+        req = urllib.request.Request(
+            cfg.get("url", "").rstrip("/") + "/oauth_token.do", data=data,
+            headers={"Content-Type": "application/x-www-form-urlencoded", "Accept": "application/json"}, method="POST")
+        with urllib.request.urlopen(req, timeout=60) as r:
+            tok = json.loads(r.read())
+        if not tok.get("access_token"):
+            raise Exception("OAuth token request failed: " + json.dumps(tok))
+        h["Authorization"] = "Bearer " + tok["access_token"]
+    else:
+        cred = (cfg.get("username", "") + ":" + cfg.get("password", "")).encode("utf-8")
+        h["Authorization"] = "Basic " + base64.b64encode(cred).decode("ascii")
+    return h
+
+
+def request(method, path, params=None, body=None, root="/api/now", versioned=True):
+    cfg = _cfg()
+    v = str(cfg.get("api_version") or "").strip().strip("/")
+    url = cfg.get("url", "").rstrip("/") + root + ("/" + v if v and versioned else "") + path
+    q = {k: str(x) for k, x in (params or {}).items() if x not in (None, "")}
+    if q:
+        url += "?" + urllib.parse.urlencode(q)
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=_headers(cfg), method=method)
+    with urllib.request.urlopen(req, timeout=90) as r:
+        raw = r.read()
+        return json.loads(raw) if raw else {}
+
+
+def split_fields(s, prefix_custom=False):
+    out = {}
+    for part in str(s or "").split(";"):
+        if "=" not in part:
+            continue
+        k, v = part.split("=", 1)
+        k = k.strip()
+        if prefix_custom and k and not k.startswith("u_"):
+            k = "u_" + k
+        if k:
+            out[k] = v
+    return out
+
+
+NAMED_FIELDS = [
+    "short_description", "description", "urgency", "impact", "priority", "state",
+    "category", "subcategory", "caller_id", "assigned_to", "assignment_group",
+    "comments", "work_notes", "close_code", "close_notes",
+]
+
+
+def main():
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    ticket_id = str(inputs.get("id") or "")
+    if not ticket_id:
+        raise Exception("id is required")
+    table = str(inputs.get("ticket_type") or _cfg().get("ticket_type") or "incident")
+    body = {}
+    for k in NAMED_FIELDS:
+        v = inputs.get(k)
+        if v not in (None, ""):
+            body[k] = v
+    body.update(split_fields(inputs.get("fields")))
+    body.update(split_fields(inputs.get("custom_fields"), prefix_custom=True))
+    if not body:
+        raise Exception("nothing to update")
+    params = {"sysparm_input_display_value": "true"} if inputs.get("input_display_value") else None
+    print(json.dumps(request("PATCH", "/table/" + urllib.parse.quote(table) + "/" + urllib.parse.quote(ticket_id), params=params, body=body)))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)

integrations/servicenow/scripts/upload_file.py

@@ -0,0 +1,63 @@
+import base64, json, mimetypes, os, sys, urllib.parse, urllib.request, urllib.error
+
+
+def _cfg():
+    return json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+
+
+def _headers(cfg):
+    h = {"Accept": "application/json", "Content-Type": "application/json"}
+    if str(cfg.get("auth_type") or "basic").lower() == "oauth":
+        data = urllib.parse.urlencode({
+            "grant_type": "password",
+            "client_id": cfg.get("client_id", ""),
+            "client_secret": cfg.get("client_secret", ""),
+            "username": cfg.get("username", ""),
+            "password": cfg.get("password", ""),
+        }).encode("utf-8")
+        req = urllib.request.Request(
+            cfg.get("url", "").rstrip("/") + "/oauth_token.do", data=data,
+            headers={"Content-Type": "application/x-www-form-urlencoded", "Accept": "application/json"}, method="POST")
+        with urllib.request.urlopen(req, timeout=60) as r:
+            tok = json.loads(r.read())
+        if not tok.get("access_token"):
+            raise Exception("OAuth token request failed: " + json.dumps(tok))
+        h["Authorization"] = "Bearer " + tok["access_token"]
+    else:
+        cred = (cfg.get("username", "") + ":" + cfg.get("password", "")).encode("utf-8")
+        h["Authorization"] = "Basic " + base64.b64encode(cred).decode("ascii")
+    return h
+
+
+def main():
+    inputs = json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+    ticket_id = str(inputs.get("id") or "")
+    if not ticket_id:
+        raise Exception("id is required")
+    cfg = _cfg()
+    table = str(inputs.get("table_name") or cfg.get("ticket_type") or "incident")
+    file_name = str(inputs.get("file_name") or "")
+    if not file_name:
+        raise Exception("file_name is required")
+    url = cfg.get("url", "").rstrip("/") + "/api/now/attachment/file?" + urllib.parse.urlencode({
+        "table_name": table,
+        "table_sys_id": ticket_id,
+        "file_name": file_name,
+    })
+    headers = _headers(cfg)
+    headers["Content-Type"] = mimetypes.guess_type(file_name)[0] or "application/octet-stream"
+    body = base64.b64decode(inputs["content_base64"])
+    req = urllib.request.Request(url, data=body, headers=headers, method="POST")
+    with urllib.request.urlopen(req, timeout=120) as r:
+        raw = r.read()
+    print(json.dumps(json.loads(raw) if raw else {}))
+
+
+try:
+    main()
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+    sys.exit(1)
+except Exception as e:
+    print(json.dumps({"error": str(e)}))
+    sys.exit(1)