@terreno/syncdb 58.0.2 → 58.0.4
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/CHANGELOG.md +31 -0
- package/dist/api/apiFetch.d.ts +2 -0
- package/dist/api/apiFetch.d.ts.map +1 -1
- package/dist/api/apiFetch.js +9 -1
- package/dist/api/apiFetch.js.map +1 -1
- package/dist/api/apiFetch.test.d.ts +2 -0
- package/dist/api/apiFetch.test.d.ts.map +1 -0
- package/dist/api/apiFetch.test.js +34 -0
- package/dist/api/apiFetch.test.js.map +1 -0
- package/dist/auth/betterAuthClient.d.ts.map +1 -1
- package/dist/auth/betterAuthClient.js +3 -2
- package/dist/auth/betterAuthClient.js.map +1 -1
- package/dist/client.test.js +16 -3
- package/dist/client.test.js.map +1 -1
- package/dist/devMcpRegistry.d.ts +49 -0
- package/dist/devMcpRegistry.d.ts.map +1 -0
- package/dist/devMcpRegistry.isolated.d.ts +2 -0
- package/dist/devMcpRegistry.isolated.d.ts.map +1 -0
- package/dist/devMcpRegistry.isolated.js +195 -0
- package/dist/devMcpRegistry.isolated.js.map +1 -0
- package/dist/devMcpRegistry.js +147 -0
- package/dist/devMcpRegistry.js.map +1 -0
- package/dist/index.d.ts +1 -0
- package/dist/index.d.ts.map +1 -1
- package/dist/index.js +1 -0
- package/dist/index.js.map +1 -1
- package/package.json +7 -7
- package/src/api/apiFetch.test.ts +45 -0
- package/src/api/apiFetch.ts +10 -1
- package/src/auth/betterAuthClient.ts +3 -2
- package/src/client.test.ts +16 -5
- package/src/devMcpRegistry.isolated.ts +217 -0
- package/src/devMcpRegistry.ts +222 -0
- package/src/index.ts +17 -0
|
@@ -0,0 +1,217 @@
|
|
|
1
|
+
import {afterEach, describe, expect, it, mock} from "bun:test";
|
|
2
|
+
import {
|
|
3
|
+
clearTerrenoDevMcpRegistryForTests,
|
|
4
|
+
getTerrenoDevClientDispatch,
|
|
5
|
+
getTerrenoDevStorageAdapter,
|
|
6
|
+
listTerrenoDevCommandSummaries,
|
|
7
|
+
registerTerrenoDevClientDispatch,
|
|
8
|
+
registerTerrenoDevCommand,
|
|
9
|
+
registerTerrenoDevStorage,
|
|
10
|
+
runTerrenoDevCommand,
|
|
11
|
+
} from "./devMcpRegistry";
|
|
12
|
+
|
|
13
|
+
describe("devMcpRegistry (module mocks)", () => {
|
|
14
|
+
afterEach((): void => {
|
|
15
|
+
clearTerrenoDevMcpRegistryForTests();
|
|
16
|
+
Reflect.deleteProperty(process.env, "TERRENO_DEV_MCP_REGISTRY_TEST");
|
|
17
|
+
Reflect.deleteProperty(globalThis as {__DEV__?: boolean}, "__DEV__");
|
|
18
|
+
});
|
|
19
|
+
|
|
20
|
+
it("registers client dispatch when __DEV__ is true", (): void => {
|
|
21
|
+
(globalThis as {__DEV__?: boolean}).__DEV__ = true;
|
|
22
|
+
registerTerrenoDevClientDispatch({
|
|
23
|
+
dispatch: ({type}) => type,
|
|
24
|
+
});
|
|
25
|
+
expect(getTerrenoDevClientDispatch()?.dispatch({type: "demo/action"})).toBe("demo/action");
|
|
26
|
+
});
|
|
27
|
+
|
|
28
|
+
it("no-ops outside dev or test", (): void => {
|
|
29
|
+
Reflect.deleteProperty(process.env, "TERRENO_DEV_MCP_REGISTRY_TEST");
|
|
30
|
+
registerTerrenoDevCommand({description: "x", handler: () => 1, name: "ghost"});
|
|
31
|
+
registerTerrenoDevClientDispatch({dispatch: () => 1});
|
|
32
|
+
registerTerrenoDevStorage({asyncStorage: false});
|
|
33
|
+
expect(listTerrenoDevCommandSummaries()).toEqual([]);
|
|
34
|
+
expect(getTerrenoDevClientDispatch()).toBeUndefined();
|
|
35
|
+
expect(getTerrenoDevStorageAdapter()).toBeUndefined();
|
|
36
|
+
});
|
|
37
|
+
|
|
38
|
+
it("registers commands and client dispatch in test mode", async (): Promise<void> => {
|
|
39
|
+
process.env.TERRENO_DEV_MCP_REGISTRY_TEST = "true";
|
|
40
|
+
registerTerrenoDevClientDispatch({
|
|
41
|
+
dispatch: (action) => action,
|
|
42
|
+
});
|
|
43
|
+
registerTerrenoDevCommand({
|
|
44
|
+
description: "Adds",
|
|
45
|
+
handler: ({a, b}) => Number(a) + Number(b),
|
|
46
|
+
name: "add",
|
|
47
|
+
});
|
|
48
|
+
expect(listTerrenoDevCommandSummaries().map((c) => c.name)).toEqual(["add"]);
|
|
49
|
+
await expect(runTerrenoDevCommand("add", {a: 1, b: 2})).resolves.toBe(3);
|
|
50
|
+
expect(getTerrenoDevClientDispatch()?.dispatch({type: "x"})).toEqual({type: "x"});
|
|
51
|
+
});
|
|
52
|
+
|
|
53
|
+
it("treats global __DEV__=true like test mode without env", async (): Promise<void> => {
|
|
54
|
+
(globalThis as {__DEV__?: boolean}).__DEV__ = true;
|
|
55
|
+
mock.module("@react-native-async-storage/async-storage", () => ({
|
|
56
|
+
default: {
|
|
57
|
+
getAllKeys: async () => [] as string[],
|
|
58
|
+
getItem: async () => null,
|
|
59
|
+
setItem: async () => {},
|
|
60
|
+
},
|
|
61
|
+
}));
|
|
62
|
+
registerTerrenoDevStorage({asyncStorage: true});
|
|
63
|
+
const adapter = getTerrenoDevStorageAdapter();
|
|
64
|
+
expect(adapter).toBeDefined();
|
|
65
|
+
});
|
|
66
|
+
|
|
67
|
+
it("returns null from get when AsyncStorage import throws", async (): Promise<void> => {
|
|
68
|
+
mock.module("@react-native-async-storage/async-storage", () => {
|
|
69
|
+
throw new Error("no async storage");
|
|
70
|
+
});
|
|
71
|
+
process.env.TERRENO_DEV_MCP_REGISTRY_TEST = "true";
|
|
72
|
+
registerTerrenoDevStorage({asyncStorage: true});
|
|
73
|
+
const adapter = getTerrenoDevStorageAdapter();
|
|
74
|
+
expect(await adapter?.get("any")).toBeNull();
|
|
75
|
+
});
|
|
76
|
+
|
|
77
|
+
it("set on allowlisted secure key fails when SecureStore import throws", async (): Promise<void> => {
|
|
78
|
+
mock.module("@react-native-async-storage/async-storage", () => ({
|
|
79
|
+
default: {
|
|
80
|
+
getAllKeys: async () => [] as string[],
|
|
81
|
+
getItem: async () => null,
|
|
82
|
+
setItem: async () => {},
|
|
83
|
+
},
|
|
84
|
+
}));
|
|
85
|
+
mock.module("expo-secure-store", () => {
|
|
86
|
+
throw new Error("missing");
|
|
87
|
+
});
|
|
88
|
+
process.env.TERRENO_DEV_MCP_REGISTRY_TEST = "true";
|
|
89
|
+
registerTerrenoDevStorage({asyncStorage: true, secureStoreKeyAllowlist: ["tok"]});
|
|
90
|
+
const adapter = getTerrenoDevStorageAdapter();
|
|
91
|
+
await expect(adapter?.set("tok", "v")).rejects.toThrow(/expo-secure-store is not available/);
|
|
92
|
+
});
|
|
93
|
+
|
|
94
|
+
it("wires AsyncStorage when asyncStorage is enabled", async (): Promise<void> => {
|
|
95
|
+
const store = new Map<string, string>([["a", "1"]]);
|
|
96
|
+
mock.module("@react-native-async-storage/async-storage", () => ({
|
|
97
|
+
default: {
|
|
98
|
+
getAllKeys: async () => [...store.keys()],
|
|
99
|
+
getItem: async (key: string) => store.get(key) ?? null,
|
|
100
|
+
setItem: async (key: string, value: string) => {
|
|
101
|
+
store.set(key, value);
|
|
102
|
+
},
|
|
103
|
+
},
|
|
104
|
+
}));
|
|
105
|
+
process.env.TERRENO_DEV_MCP_REGISTRY_TEST = "true";
|
|
106
|
+
registerTerrenoDevStorage({asyncStorage: true});
|
|
107
|
+
const adapter = getTerrenoDevStorageAdapter();
|
|
108
|
+
expect(await adapter?.listKeys()).toEqual(["a"]);
|
|
109
|
+
expect(await adapter?.get("a")).toBe("1");
|
|
110
|
+
await adapter?.set("b", "2");
|
|
111
|
+
expect(store.get("b")).toBe("2");
|
|
112
|
+
mock.module("@react-native-async-storage/async-storage", () => ({
|
|
113
|
+
default: undefined,
|
|
114
|
+
}));
|
|
115
|
+
});
|
|
116
|
+
|
|
117
|
+
it("returns null for secure key when SecureStore module is unavailable", async (): Promise<void> => {
|
|
118
|
+
mock.module("expo-secure-store", () => {
|
|
119
|
+
throw new Error("missing");
|
|
120
|
+
});
|
|
121
|
+
mock.module("@react-native-async-storage/async-storage", () => ({
|
|
122
|
+
default: {
|
|
123
|
+
getAllKeys: async () => [] as string[],
|
|
124
|
+
getItem: async () => null,
|
|
125
|
+
setItem: async () => {},
|
|
126
|
+
},
|
|
127
|
+
}));
|
|
128
|
+
process.env.TERRENO_DEV_MCP_REGISTRY_TEST = "true";
|
|
129
|
+
registerTerrenoDevStorage({asyncStorage: true, secureStoreKeyAllowlist: ["tok"]});
|
|
130
|
+
const adapter = getTerrenoDevStorageAdapter();
|
|
131
|
+
expect(await adapter?.get("tok")).toBeNull();
|
|
132
|
+
});
|
|
133
|
+
|
|
134
|
+
it("set on secure key fails when SecureStore rejects write", async (): Promise<void> => {
|
|
135
|
+
mock.module("@react-native-async-storage/async-storage", () => ({
|
|
136
|
+
default: {
|
|
137
|
+
getAllKeys: async () => [] as string[],
|
|
138
|
+
getItem: async () => null,
|
|
139
|
+
setItem: async () => {},
|
|
140
|
+
},
|
|
141
|
+
}));
|
|
142
|
+
mock.module("expo-secure-store", () => ({
|
|
143
|
+
getItemAsync: async () => null,
|
|
144
|
+
setItemAsync: async () => {
|
|
145
|
+
throw new Error("secure full");
|
|
146
|
+
},
|
|
147
|
+
}));
|
|
148
|
+
process.env.TERRENO_DEV_MCP_REGISTRY_TEST = "true";
|
|
149
|
+
registerTerrenoDevStorage({asyncStorage: true, secureStoreKeyAllowlist: ["tok"]});
|
|
150
|
+
const adapter = getTerrenoDevStorageAdapter();
|
|
151
|
+
await expect(adapter?.set("tok", "v")).rejects.toThrow(/secure full/);
|
|
152
|
+
});
|
|
153
|
+
|
|
154
|
+
it("set throws when AsyncStorage is unavailable", async (): Promise<void> => {
|
|
155
|
+
mock.module("@react-native-async-storage/async-storage", () => ({default: undefined}));
|
|
156
|
+
process.env.TERRENO_DEV_MCP_REGISTRY_TEST = "true";
|
|
157
|
+
registerTerrenoDevStorage({asyncStorage: true});
|
|
158
|
+
const adapter = getTerrenoDevStorageAdapter();
|
|
159
|
+
await expect(adapter?.set("k", "v")).rejects.toThrow(/not available/);
|
|
160
|
+
});
|
|
161
|
+
|
|
162
|
+
it("set rejects keys that are not writable", async (): Promise<void> => {
|
|
163
|
+
process.env.TERRENO_DEV_MCP_REGISTRY_TEST = "true";
|
|
164
|
+
mock.module("@react-native-async-storage/async-storage", () => ({
|
|
165
|
+
default: {
|
|
166
|
+
getAllKeys: async () => [] as string[],
|
|
167
|
+
getItem: async () => null,
|
|
168
|
+
setItem: async () => {},
|
|
169
|
+
},
|
|
170
|
+
}));
|
|
171
|
+
registerTerrenoDevStorage({asyncStorage: true});
|
|
172
|
+
const adapter = getTerrenoDevStorageAdapter();
|
|
173
|
+
await expect(adapter?.set("secure:nope", "x")).rejects.toThrow(/not writable/);
|
|
174
|
+
});
|
|
175
|
+
|
|
176
|
+
it("listKeys merges AsyncStorage keys with every allowlisted secure key", async (): Promise<void> => {
|
|
177
|
+
mock.module("@react-native-async-storage/async-storage", () => ({
|
|
178
|
+
default: {
|
|
179
|
+
getAllKeys: async () => ["z", "a"],
|
|
180
|
+
getItem: async () => null,
|
|
181
|
+
setItem: async () => {},
|
|
182
|
+
},
|
|
183
|
+
}));
|
|
184
|
+
mock.module("expo-secure-store", () => ({
|
|
185
|
+
getItemAsync: async () => null,
|
|
186
|
+
setItemAsync: async () => {},
|
|
187
|
+
}));
|
|
188
|
+
process.env.TERRENO_DEV_MCP_REGISTRY_TEST = "true";
|
|
189
|
+
registerTerrenoDevStorage({asyncStorage: true, secureStoreKeyAllowlist: ["token", "other"]});
|
|
190
|
+
const adapter = getTerrenoDevStorageAdapter();
|
|
191
|
+
expect(await adapter?.listKeys()).toEqual(["a", "other", "token", "z"]);
|
|
192
|
+
});
|
|
193
|
+
|
|
194
|
+
it("reads and writes allowlisted SecureStore keys when module loads", async (): Promise<void> => {
|
|
195
|
+
mock.module("expo-secure-store", () => ({
|
|
196
|
+
getItemAsync: async (key: string) => (key === "token" ? "secret" : null),
|
|
197
|
+
setItemAsync: async (key: string, value: string) => {
|
|
198
|
+
expect(key).toBe("token");
|
|
199
|
+
expect(value).toBe("next");
|
|
200
|
+
},
|
|
201
|
+
}));
|
|
202
|
+
mock.module("@react-native-async-storage/async-storage", () => ({
|
|
203
|
+
default: {
|
|
204
|
+
getAllKeys: async () => [] as string[],
|
|
205
|
+
getItem: async () => null,
|
|
206
|
+
setItem: async () => {},
|
|
207
|
+
},
|
|
208
|
+
}));
|
|
209
|
+
process.env.TERRENO_DEV_MCP_REGISTRY_TEST = "true";
|
|
210
|
+
registerTerrenoDevStorage({asyncStorage: true, secureStoreKeyAllowlist: ["token"]});
|
|
211
|
+
const adapter = getTerrenoDevStorageAdapter();
|
|
212
|
+
expect(await adapter?.get("token")).toBe("secret");
|
|
213
|
+
await adapter?.set("token", "next");
|
|
214
|
+
mock.module("expo-secure-store", () => ({}));
|
|
215
|
+
mock.module("@react-native-async-storage/async-storage", () => ({default: undefined}));
|
|
216
|
+
});
|
|
217
|
+
});
|
|
@@ -0,0 +1,222 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Dev-only hooks for terreno-mcp-local: local storage inspection and custom commands.
|
|
3
|
+
* Registers globals the MCP server reads through CDP `Runtime.evaluate`.
|
|
4
|
+
*/
|
|
5
|
+
declare const __DEV__: boolean | undefined;
|
|
6
|
+
|
|
7
|
+
export interface TerrenoDevStorageAdapter {
|
|
8
|
+
canWriteKey: (key: string) => boolean;
|
|
9
|
+
get: (key: string) => Promise<string | null>;
|
|
10
|
+
listKeys: () => Promise<string[]>;
|
|
11
|
+
set: (key: string, value: string) => Promise<void>;
|
|
12
|
+
}
|
|
13
|
+
|
|
14
|
+
export interface RegisterTerrenoDevStorageOptions {
|
|
15
|
+
/** Wire `@react-native-async-storage/async-storage` (default true). */
|
|
16
|
+
asyncStorage?: boolean;
|
|
17
|
+
/** SecureStore key names allowed for MCP read/write when expo-secure-store is installed. */
|
|
18
|
+
secureStoreKeyAllowlist?: string[];
|
|
19
|
+
}
|
|
20
|
+
|
|
21
|
+
interface TerrenoDevCommandInputSchema {
|
|
22
|
+
properties?: Record<string, {type?: string; description?: string}>;
|
|
23
|
+
type?: string;
|
|
24
|
+
}
|
|
25
|
+
|
|
26
|
+
export interface TerrenoDevCommandDefinition {
|
|
27
|
+
description: string;
|
|
28
|
+
handler: (args: Record<string, unknown>) => Promise<unknown> | unknown;
|
|
29
|
+
inputSchema?: TerrenoDevCommandInputSchema;
|
|
30
|
+
}
|
|
31
|
+
|
|
32
|
+
export interface TerrenoDevCommandSummary {
|
|
33
|
+
description: string;
|
|
34
|
+
inputSchema?: TerrenoDevCommandInputSchema;
|
|
35
|
+
name: string;
|
|
36
|
+
}
|
|
37
|
+
|
|
38
|
+
export interface TerrenoDevClientAction {
|
|
39
|
+
payload?: unknown;
|
|
40
|
+
type: string;
|
|
41
|
+
}
|
|
42
|
+
|
|
43
|
+
export interface TerrenoDevClientDispatch {
|
|
44
|
+
dispatch: (action: TerrenoDevClientAction) => unknown;
|
|
45
|
+
}
|
|
46
|
+
|
|
47
|
+
type DevMcpGlobal = typeof globalThis & {
|
|
48
|
+
__TERRENO_DEV_CLIENT_DISPATCH__?: TerrenoDevClientDispatch;
|
|
49
|
+
__TERRENO_DEV_COMMANDS__?: Record<string, TerrenoDevCommandDefinition>;
|
|
50
|
+
__TERRENO_DEV_STORAGE__?: TerrenoDevStorageAdapter;
|
|
51
|
+
};
|
|
52
|
+
|
|
53
|
+
const isDevOrTest = (): boolean => {
|
|
54
|
+
if (typeof __DEV__ !== "undefined" && __DEV__) {
|
|
55
|
+
return true;
|
|
56
|
+
}
|
|
57
|
+
if (process.env.TERRENO_DEV_MCP_REGISTRY_TEST === "true") {
|
|
58
|
+
return true;
|
|
59
|
+
}
|
|
60
|
+
return false;
|
|
61
|
+
};
|
|
62
|
+
|
|
63
|
+
export const clearTerrenoDevMcpRegistryForTests = (): void => {
|
|
64
|
+
const g = globalThis as DevMcpGlobal;
|
|
65
|
+
delete g.__TERRENO_DEV_CLIENT_DISPATCH__;
|
|
66
|
+
delete g.__TERRENO_DEV_COMMANDS__;
|
|
67
|
+
delete g.__TERRENO_DEV_STORAGE__;
|
|
68
|
+
};
|
|
69
|
+
|
|
70
|
+
/** Optional client-side action bus for `dispatch_client_action` (Terreno 58 SyncDB apps). */
|
|
71
|
+
export const registerTerrenoDevClientDispatch = (dispatch: TerrenoDevClientDispatch): void => {
|
|
72
|
+
if (!isDevOrTest()) {
|
|
73
|
+
return;
|
|
74
|
+
}
|
|
75
|
+
(globalThis as DevMcpGlobal).__TERRENO_DEV_CLIENT_DISPATCH__ = dispatch;
|
|
76
|
+
};
|
|
77
|
+
|
|
78
|
+
export const getTerrenoDevClientDispatch = (): TerrenoDevClientDispatch | undefined => {
|
|
79
|
+
return (globalThis as DevMcpGlobal).__TERRENO_DEV_CLIENT_DISPATCH__;
|
|
80
|
+
};
|
|
81
|
+
|
|
82
|
+
export const registerTerrenoDevStorage = (options: RegisterTerrenoDevStorageOptions = {}): void => {
|
|
83
|
+
if (!isDevOrTest()) {
|
|
84
|
+
return;
|
|
85
|
+
}
|
|
86
|
+
const asyncStorageEnabled = options.asyncStorage !== false;
|
|
87
|
+
const secureAllowlist = new Set(options.secureStoreKeyAllowlist ?? []);
|
|
88
|
+
|
|
89
|
+
const adapter: TerrenoDevStorageAdapter = {
|
|
90
|
+
canWriteKey: (key: string): boolean => {
|
|
91
|
+
if (secureAllowlist.has(key)) {
|
|
92
|
+
return true;
|
|
93
|
+
}
|
|
94
|
+
return !key.startsWith("secure:");
|
|
95
|
+
},
|
|
96
|
+
get: async (key: string): Promise<string | null> => {
|
|
97
|
+
if (secureAllowlist.has(key)) {
|
|
98
|
+
const secure = await importSecureStore();
|
|
99
|
+
if (!secure) {
|
|
100
|
+
return null;
|
|
101
|
+
}
|
|
102
|
+
return secure.getItemAsync(key);
|
|
103
|
+
}
|
|
104
|
+
if (!asyncStorageEnabled) {
|
|
105
|
+
return null;
|
|
106
|
+
}
|
|
107
|
+
const storage = await importAsyncStorage();
|
|
108
|
+
if (!storage) {
|
|
109
|
+
return null;
|
|
110
|
+
}
|
|
111
|
+
return storage.getItem(key);
|
|
112
|
+
},
|
|
113
|
+
listKeys: async (): Promise<string[]> => {
|
|
114
|
+
const keys: string[] = [];
|
|
115
|
+
if (asyncStorageEnabled) {
|
|
116
|
+
const storage = await importAsyncStorage();
|
|
117
|
+
if (storage) {
|
|
118
|
+
keys.push(...(await storage.getAllKeys()));
|
|
119
|
+
}
|
|
120
|
+
}
|
|
121
|
+
for (const secureKey of secureAllowlist) {
|
|
122
|
+
keys.push(secureKey);
|
|
123
|
+
}
|
|
124
|
+
return [...new Set(keys)].sort();
|
|
125
|
+
},
|
|
126
|
+
set: async (key: string, value: string): Promise<void> => {
|
|
127
|
+
if (!adapter.canWriteKey(key)) {
|
|
128
|
+
throw new Error(`Key not writable via MCP: ${key}`);
|
|
129
|
+
}
|
|
130
|
+
if (secureAllowlist.has(key)) {
|
|
131
|
+
const secure = await importSecureStore();
|
|
132
|
+
if (!secure) {
|
|
133
|
+
throw new Error("expo-secure-store is not available");
|
|
134
|
+
}
|
|
135
|
+
await secure.setItemAsync(key, value);
|
|
136
|
+
return;
|
|
137
|
+
}
|
|
138
|
+
const storage = await importAsyncStorage();
|
|
139
|
+
if (!storage) {
|
|
140
|
+
throw new Error("@react-native-async-storage/async-storage is not available");
|
|
141
|
+
}
|
|
142
|
+
await storage.setItem(key, value);
|
|
143
|
+
},
|
|
144
|
+
};
|
|
145
|
+
|
|
146
|
+
(globalThis as DevMcpGlobal).__TERRENO_DEV_STORAGE__ = adapter;
|
|
147
|
+
};
|
|
148
|
+
|
|
149
|
+
export const registerTerrenoDevCommand = (
|
|
150
|
+
definition: TerrenoDevCommandDefinition & {
|
|
151
|
+
name: string;
|
|
152
|
+
}
|
|
153
|
+
): void => {
|
|
154
|
+
if (!isDevOrTest()) {
|
|
155
|
+
return;
|
|
156
|
+
}
|
|
157
|
+
const {name, ...rest} = definition;
|
|
158
|
+
if (!name.trim()) {
|
|
159
|
+
throw new Error("registerTerrenoDevCommand requires a non-empty name");
|
|
160
|
+
}
|
|
161
|
+
const g = globalThis as DevMcpGlobal;
|
|
162
|
+
if (!g.__TERRENO_DEV_COMMANDS__) {
|
|
163
|
+
g.__TERRENO_DEV_COMMANDS__ = {};
|
|
164
|
+
}
|
|
165
|
+
if (g.__TERRENO_DEV_COMMANDS__[name]) {
|
|
166
|
+
throw new Error(`Dev command already registered: ${name}`);
|
|
167
|
+
}
|
|
168
|
+
g.__TERRENO_DEV_COMMANDS__[name] = rest;
|
|
169
|
+
};
|
|
170
|
+
|
|
171
|
+
export const listTerrenoDevCommandSummaries = (): TerrenoDevCommandSummary[] => {
|
|
172
|
+
const g = globalThis as DevMcpGlobal;
|
|
173
|
+
const map = g.__TERRENO_DEV_COMMANDS__ ?? {};
|
|
174
|
+
return Object.entries(map)
|
|
175
|
+
.map(([name, cmd]) => ({
|
|
176
|
+
description: cmd.description,
|
|
177
|
+
inputSchema: cmd.inputSchema,
|
|
178
|
+
name,
|
|
179
|
+
}))
|
|
180
|
+
.sort((a, b) => a.name.localeCompare(b.name));
|
|
181
|
+
};
|
|
182
|
+
|
|
183
|
+
export const runTerrenoDevCommand = async (
|
|
184
|
+
name: string,
|
|
185
|
+
args: Record<string, unknown> = {}
|
|
186
|
+
): Promise<unknown> => {
|
|
187
|
+
const g = globalThis as DevMcpGlobal;
|
|
188
|
+
const cmd = g.__TERRENO_DEV_COMMANDS__?.[name];
|
|
189
|
+
if (!cmd) {
|
|
190
|
+
throw new Error(`Unknown dev command: ${name}`);
|
|
191
|
+
}
|
|
192
|
+
return cmd.handler(args);
|
|
193
|
+
};
|
|
194
|
+
|
|
195
|
+
export const getTerrenoDevStorageAdapter = (): TerrenoDevStorageAdapter | undefined => {
|
|
196
|
+
return (globalThis as DevMcpGlobal).__TERRENO_DEV_STORAGE__;
|
|
197
|
+
};
|
|
198
|
+
|
|
199
|
+
const importAsyncStorage = async (): Promise<{
|
|
200
|
+
getAllKeys: () => Promise<readonly string[]>;
|
|
201
|
+
getItem: (key: string) => Promise<string | null>;
|
|
202
|
+
setItem: (key: string, value: string) => Promise<void>;
|
|
203
|
+
} | null> => {
|
|
204
|
+
try {
|
|
205
|
+
const mod = await import("@react-native-async-storage/async-storage");
|
|
206
|
+
return mod.default;
|
|
207
|
+
} catch {
|
|
208
|
+
return null;
|
|
209
|
+
}
|
|
210
|
+
};
|
|
211
|
+
|
|
212
|
+
const importSecureStore = async (): Promise<{
|
|
213
|
+
getItemAsync: (key: string) => Promise<string | null>;
|
|
214
|
+
setItemAsync: (key: string, value: string) => Promise<void>;
|
|
215
|
+
} | null> => {
|
|
216
|
+
try {
|
|
217
|
+
const mod = await import("expo-secure-store");
|
|
218
|
+
return mod;
|
|
219
|
+
} catch {
|
|
220
|
+
return null;
|
|
221
|
+
}
|
|
222
|
+
};
|
package/src/index.ts
CHANGED
|
@@ -197,3 +197,20 @@ export {
|
|
|
197
197
|
type InstallTerrenoDevConsoleLoggerArgs,
|
|
198
198
|
installTerrenoDevConsoleLogger,
|
|
199
199
|
} from "./devConsoleLogger";
|
|
200
|
+
|
|
201
|
+
export {
|
|
202
|
+
clearTerrenoDevMcpRegistryForTests,
|
|
203
|
+
getTerrenoDevClientDispatch,
|
|
204
|
+
getTerrenoDevStorageAdapter,
|
|
205
|
+
listTerrenoDevCommandSummaries,
|
|
206
|
+
type RegisterTerrenoDevStorageOptions,
|
|
207
|
+
registerTerrenoDevClientDispatch,
|
|
208
|
+
registerTerrenoDevCommand,
|
|
209
|
+
registerTerrenoDevStorage,
|
|
210
|
+
runTerrenoDevCommand,
|
|
211
|
+
type TerrenoDevClientAction,
|
|
212
|
+
type TerrenoDevClientDispatch,
|
|
213
|
+
type TerrenoDevCommandDefinition,
|
|
214
|
+
type TerrenoDevCommandSummary,
|
|
215
|
+
type TerrenoDevStorageAdapter,
|
|
216
|
+
} from "./devMcpRegistry";
|