FilesExpand file tree

main

/

runtime.ts

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

61 lines (55 loc) · 2.16 KB

main

/

runtime.ts

Copy path

Top

File metadata and controls

• Code
• Blame

61 lines (55 loc) · 2.16 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

import { readFile } from "node:fs/promises";

import { realpathSync } from "node:fs";

import { fileURLToPath, pathToFileURL } from "node:url";

export async function readStdinText(): Promise<string> {

const chunks: Buffer[] = [];

for await (const chunk of process.stdin) {

chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));

}

return Buffer.concat(chunks).toString("utf8");

}

export async function readStdinJson<T>(): Promise<T> {

return JSON.parse(await readStdinText()) as T;

}

export function readTextFile(filePath: string): Promise<string> {

return readFile(filePath, "utf8");

}

// Each host names the plugin's install path after itself: Cursor sets CURSOR_PLUGIN_ROOT,

// Claude Code and Grok set CLAUDE_PLUGIN_ROOT, and Grok also sets GROK_PLUGIN_ROOT. A value

// that still reads "${...}" means the host passed the token through without expanding it.

export function pluginRootFromEnv(env: NodeJS.ProcessEnv = process.env): string | undefined {

return [env.CURSOR_PLUGIN_ROOT, env.CLAUDE_PLUGIN_ROOT, env.GROK_PLUGIN_ROOT].find(

(value): value is string => !!value && !value.includes("${"),

);

}

// Node realpaths the ESM entry but not argv[1]; compare resolved paths so a symlinked plugin dir still matches.

export function isMainModule(metaUrl: string): boolean {

const entry = process.argv[1];

if (!entry) return false;

try {

return realpathSync(entry) === realpathSync(fileURLToPath(metaUrl));

} catch {

return pathToFileURL(entry).href === metaUrl;

}

}

export async function runHook<T>(

handler: (input: T) => void | Promise<void>,

fallback: Record<string, unknown> = { continue: true },

): Promise<void> {

const write = process.stdout.write.bind(process.stdout);

let answered = false;

process.stdout.write = ((...args: Parameters<typeof write>) => {

answered = true;

return write(...args);

}) as typeof process.stdout.write;

try {

await handler(await readStdinJson<T>());

} catch (error) {

if (process.env.SUPERMEMORY_DEBUG === "true") {

console.error("[supermemory] hook failed:", error);

}

if (!answered) write(JSON.stringify(fallback));

} finally {

process.stdout.write = write;

}

}