FilesExpand file tree

main

/

sync-mcp-model.sh

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

executable file

·

150 lines (135 loc) · 6.29 KB

main

/

sync-mcp-model.sh

Copy path

Top

File metadata and controls

• Code
• Blame

executable file

·

150 lines (135 loc) · 6.29 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

#!/bin/sh

# Sync the vendored basecamp-sdk model snapshot that MCP catalog generation reads.

#

# The catalog derives from basecamp-sdk's behavior model (per-operation traits:

# readonly, idempotent, pagination, retry) joined with its exported OpenAPI

# spec (operationId, method, path, tags, docs, parameter schemas). Both files

# are build products of basecamp-sdk's Smithy model, so we vendor a snapshot

# here rather than parse Smithy ourselves: CI stays hermetic and the reviewed

# diff shows exactly which surface changed when the SDK moves. Keep the

# snapshot in lockstep with the basecamp-sdk version pinned in go.mod —

# TestCatalogModelProvenance enforces it.

#

# Tag patch: the toolkit catalog joins operations to domains by tag (exactly

# one per operation, refused otherwise), and the SDK export used to leave a

# handful of operations untagged. It no longer does, so PATCHED_TAGS is empty

# and the only divergences from the upstream export are EXCLUDED_OPERATIONS

# and POLICY_EXCLUDED_OPERATIONS.

# The table stays as a seam: an operation that grew an upstream tag is a

# sync-time conflict rather than a silent double-tag, and an operation that

# arrives untagged stops the sync rather than failing later at Load.

#

# Exclusions: raw-binary upload operations (multipart/octet-stream bodies)

# can't ride the JSON tool-call convention, and the toolkit refuses non-JSON

# bodies at load, so they are dropped from both model files here. Uploads

# stay a CLI affair (basecamp attach / upload).

#

# CreateStreamTicket is excluded for the opposite reason (POLICY_EXCLUDED_

# OPERATIONS, which is not held to the "still not JSON" check): it rides the

# convention fine, but its result is a replayable bearer and a URL that embeds

# it, and the dispatcher returns a result verbatim into a model transcript

# with no reveal opt-in. Nothing on this surface could use the ticket anyway —

# opening the stream needs a WebSocket, which a JSON tool call is not — so the

# mint stays a CLI affair (basecamp events ticket --show-secret).

#

# Usage: scripts/sync-mcp-model.sh [path-to-basecamp-sdk-checkout]

set -eu

sdk="${1:-../basecamp-sdk}"

dest="$(dirname "$0")/../internal/mcpserver/model"

# Resolve provenance before touching the destination, so a checkout that is

# not a git repo (or otherwise broken) can't leave a torn snapshot behind.

# --dirty marks a checkout with uncommitted changes, so modified model files

# are never recorded as a clean release tag.

commit=$(git -C "$sdk" rev-parse HEAD)

ref=$(git -C "$sdk" describe --tags --always --dirty)

for f in behavior-model.json openapi.json; do

[ -f "$sdk/$f" ] || { echo "missing $sdk/$f (pass a basecamp-sdk checkout path)" >&2; exit 1; }

done

# Copy both model files, assigning tags to the operations the export leaves

# untagged and dropping the raw-binary upload operations. Refuses an

# operation that grew an upstream tag (drop it from the table then) and

# refuses any untagged operation the table doesn't cover, so the patches can

# only shrink as upstream catches up.

python3 - "$sdk" "$dest" <<'PY'

import json, sys

EXCLUDED_OPERATIONS = {

"CreateAttachment",

"CreateCampfireUpload",

"UpdateAccountLogo",

"UpdateProjectWallpaper",

}

# Excluded by policy rather than by body shape, so these are not held to the

# "still not JSON" check above: they would ride the convention, we decline to

# serve them.

POLICY_EXCLUDED_OPERATIONS = {

"CreateStreamTicket",

}

PATCHED_TAGS: dict[str, str] = {

# Empty: basecamp-sdk now tags every exported operation itself

# (basecamp-sdk#878). Kept as a seam, because the export has left

# operations untagged before and the catalog join refuses them.

}

sdk, dest = sys.argv[1], sys.argv[2]

with open(f"{sdk}/openapi.json") as f:

doc = json.load(f)

patched = []

excluded = []

for path in list(doc["paths"]):

methods = doc["paths"][path]

for method in list(methods):

op = methods[method]

if not isinstance(op, dict) or "operationId" not in op:

continue

oid = op["operationId"]

if oid in EXCLUDED_OPERATIONS:

body = op.get("requestBody", {}).get("content", {})

if "application/json" in body or not body:

sys.exit(f"{oid} takes a JSON body now — drop it from EXCLUDED_OPERATIONS")

del methods[method]

excluded.append(oid)

continue

if oid in POLICY_EXCLUDED_OPERATIONS:

del methods[method]

excluded.append(oid)

continue

tags = op.get("tags") or []

if oid in PATCHED_TAGS:

if tags:

sys.exit(f"{oid} is tagged {tags} upstream now — drop it from PATCHED_TAGS")

op["tags"] = [PATCHED_TAGS[oid]]

patched.append(oid)

elif not tags:

sys.exit(f"{oid} is untagged and not in PATCHED_TAGS — assign it a domain tag")

if not methods:

del doc["paths"][path]

missing = sorted(set(PATCHED_TAGS) - set(patched))

if missing:

sys.exit(f"PATCHED_TAGS entries not found in the export: {missing}")

missing = sorted((EXCLUDED_OPERATIONS | POLICY_EXCLUDED_OPERATIONS) - set(excluded))

if missing:

sys.exit(f"excluded operations not found in the export: {missing}")

with open(f"{dest}/openapi.json", "w") as f:

json.dump(doc, f, indent=2)

f.write("\n")

# The catalog join is strict both ways, so the excluded operations leave the

# behavior model too.

with open(f"{sdk}/behavior-model.json") as f:

bm = json.load(f)

for oid in EXCLUDED_OPERATIONS | POLICY_EXCLUDED_OPERATIONS:

bm["operations"].pop(oid, None)

with open(f"{dest}/behavior-model.json", "w") as f:

json.dump(bm, f, indent=2)

f.write("\n")

print(f"patched tags onto {len(patched)} untagged operations; excluded {len(excluded)} operations")

PY

cat > "$dest/PROVENANCE.json" <<JSON

{

"source": "github.com/basecamp/basecamp-sdk",

"commit": "$commit",

"ref": "$ref",

"files": ["behavior-model.json", "openapi.json"],

"synced_by": "scripts/sync-mcp-model.sh",

"patches": "binary-upload operations dropped because the toolkit refuses their non-JSON bodies (EXCLUDED_OPERATIONS) and the stream-ticket mint dropped by policy (POLICY_EXCLUDED_OPERATIONS); no tag patches applied (PATCHED_TAGS is empty — the export tags every operation) — see the sync script"

}

JSON

echo "synced model from basecamp-sdk @ $ref ($commit)"