@tokenwarden/opencode 0.1.0

package/dist/src/plugin/index.js

@@ -0,0 +1,492 @@
+import { tool } from "@opencode-ai/plugin";
+import { spawn } from "node:child_process";
+import { formatBillingStatus, tokenWardenSiteURL } from "../core/billing.js";
+import { formatCompactNumber, formatCompactSavingsToast, formatTokenReport } from "../core/format.js";
+import { reducePlainTextForContext } from "../core/log-reducer.js";
+import { createProtectedEngine } from "../core/protection/engine.js";
+import { appendFailureLog, createStore } from "../core/storage.js";
+const DEFAULTS = {
+    maxToolOutputTokens: 1200,
+    maxContextPartTokens: 1600,
+    mode: "balanced",
+    showToasts: true,
+    showReportToastOnSessionIdle: true,
+};
+export const TokenWardenPlugin = async ({ client, directory }, options) => {
+    const config = normalizeOptions(options);
+    const engine = await createProtectedEngine({ dataDir: config.dataDir });
+    const failureLogStore = createStore(config.dataDir);
+    const idleToastSignatures = new Map();
+    async function logFailure(input) {
+        const error = input.error;
+        try {
+            await appendFailureLog(failureLogStore, {
+                stage: input.stage,
+                sessionID: input.sessionID,
+                callID: input.callID,
+                tool: input.tool,
+                command: input.command,
+                name: typeof error.name === "string" ? error.name : undefined,
+                message: typeof error.message === "string" ? error.message : String(input.error),
+                stack: typeof error.stack === "string" ? error.stack : undefined,
+            });
+        }
+        catch {
+            // Tool failures must never cascade into opencode tool execution failures.
+        }
+    }
+    async function showSavingsToast(sessionID, savedTokens, percentSaved) {
+        if (!config.showToasts || savedTokens <= 0)
+            return;
+        try {
+            await client.tui.showToast({
+                body: {
+                    message: `TokenWarden observed ${savedTokens.toLocaleString()} optimized-context tokens saved (saved ${percentSaved.toFixed(1)}%)`,
+                    variant: "success",
+                },
+            });
+        }
+        catch {
+            // The same plugin can run outside the TUI during tests or server-only use.
+        }
+    }
+    async function showReportToast(sessionID, options = {}) {
+        if (!config.showToasts || (!options.force && !config.showReportToastOnSessionIdle))
+            return;
+        const summary = await engine.summarize(sessionID);
+        const entitlement = await engine.billing();
+        const signature = `${summary.wouldHaveUsedTokens}:${summary.usedTokens}:${summary.savedTokens}`;
+        const signatureKey = sessionID ?? "all-sessions";
+        if (!options.force && idleToastSignatures.get(signatureKey) === signature)
+            return;
+        idleToastSignatures.set(signatureKey, signature);
+        const toast = formatCompactSavingsToast(summary, entitlement);
+        const title = sessionID ? toast.title : `TokenWarden all sessions saved ${summary.percentSaved.toFixed(1)}%`;
+        const message = sessionID
+            ? toast.message
+            : `${summary.sessions.toLocaleString()} sessions, ${formatCompactNumber(summary.wouldHaveUsedTokens)} -> ${formatCompactNumber(summary.usedTokens)}, saved ${formatCompactNumber(summary.savedTokens)}`;
+        try {
+            await client.tui.showToast({
+                body: {
+                    title,
+                    message,
+                    variant: toast.variant,
+                },
+            });
+        }
+        catch {
+            // Ignore missing TUI.
+        }
+    }
+    async function showConnectToast() {
+        let openedURL;
+        const activation = await engine.activate({
+            onVerificationURL(url) {
+                openedURL = url;
+                const opened = openBrowser(url);
+                client.tui.showToast({
+                    body: {
+                        title: "Connect TokenWarden",
+                        message: opened ? "Browser opened. Waiting for authorization..." : `Open: ${url}`,
+                        variant: "info",
+                        duration: 12000,
+                    },
+                }).catch(() => { });
+            },
+        });
+        const entitlement = await engine.billing();
+        try {
+            await client.tui.showToast({
+                body: {
+                    title: "TokenWarden hosted license activated",
+                    message: `${formatBillingStatus(entitlement)} | Offline grace until ${activation.offlineGraceUntil}${openedURL ? " | Browser authorization complete." : ""}`,
+                    variant: "info",
+                    duration: 12000,
+                },
+            });
+        }
+        catch {
+            // Ignore missing TUI.
+        }
+    }
+    async function showStatusToast() {
+        const entitlement = await engine.billing();
+        try {
+            await client.tui.showToast({
+                body: {
+                    title: "TokenWarden status",
+                    message: formatBillingStatus(entitlement),
+                    variant: "info",
+                    duration: 12000,
+                },
+            });
+        }
+        catch {
+            // Ignore missing TUI.
+        }
+    }
+    async function showAccountToast() {
+        const entitlement = await engine.billing();
+        const url = accountPageURL(entitlement);
+        const opened = openBrowser(url);
+        try {
+            await client.tui.showToast({
+                body: {
+                    title: "TokenWarden account",
+                    message: opened ? "Account page opened." : `Open: ${url}`,
+                    variant: "info",
+                    duration: 12000,
+                },
+            });
+        }
+        catch {
+            // Ignore missing TUI.
+        }
+    }
+    async function showDisconnectToast() {
+        await engine.disconnect();
+        const entitlement = await engine.billing();
+        try {
+            await client.tui.showToast({
+                body: {
+                    title: "TokenWarden disconnected",
+                    message: `Reverted to free seat. ${formatBillingStatus(entitlement)}`,
+                    variant: "info",
+                    duration: 12000,
+                },
+            });
+        }
+        catch {
+            // Ignore missing TUI.
+        }
+    }
+    function normalizeCommand(command) {
+        return command.trim().replace(/^\/+/, "");
+    }
+    function isReportCommand(command) {
+        return normalizeCommand(command) === "tokenwarden-report";
+    }
+    function isConnectCommand(command) {
+        return normalizeCommand(command) === "tokenwarden-connect";
+    }
+    function isStatusCommand(command) {
+        return normalizeCommand(command) === "tokenwarden-status";
+    }
+    function isAccountCommand(command) {
+        return normalizeCommand(command) === "tokenwarden-account";
+    }
+    function isDisconnectCommand(command) {
+        return normalizeCommand(command) === "tokenwarden-disconnect";
+    }
+    return {
+        config: async (cfg) => {
+            cfg.command ??= {};
+            cfg.command["tokenwarden-report"] ??= {
+                description: "Show TokenWarden savings across all locally recorded sessions without an AI call.",
+                template: "TokenWarden handles this command locally before the AI runs.",
+            };
+            cfg.command["tokenwarden-connect"] ??= {
+                description: "Connect TokenWarden billing account locally without an AI call.",
+                template: "TokenWarden handles this command locally before the AI runs.",
+            };
+            cfg.command["tokenwarden-status"] ??= {
+                description: "Show TokenWarden status in the TUI without opening a browser or spending an AI call.",
+                template: "TokenWarden handles this command locally before the AI runs.",
+            };
+            cfg.command["tokenwarden-account"] ??= {
+                description: "Open your TokenWarden account page without an AI call.",
+                template: "TokenWarden handles this command locally before the AI runs.",
+            };
+            cfg.command["tokenwarden-disconnect"] ??= {
+                description: "Disconnect the current TokenWarden account and revert to the free seat without an AI call.",
+                template: "TokenWarden handles this command locally before the AI runs.",
+            };
+        },
+        event: async ({ event }) => {
+            const sessionID = sessionIDFromEvent(event);
+            if (event.type === "tui.command.execute") {
+                const command = normalizeCommand(String(event.properties.command ?? ""));
+                if (isReportCommand(command)) {
+                    await showReportToast(undefined, { force: true });
+                }
+                if (isConnectCommand(command))
+                    await showConnectToast();
+                if (isStatusCommand(command))
+                    await showStatusToast();
+                if (isAccountCommand(command))
+                    await showAccountToast();
+                if (isDisconnectCommand(command))
+                    await showDisconnectToast();
+                return;
+            }
+            if (event.type === "session.idle") {
+                await showReportToast(sessionID);
+                return;
+            }
+            if (event.type !== "session.created" || !config.showToasts)
+                return;
+            try {
+                await client.tui.showToast({
+                    body: {
+                        message: "TokenWarden active. Run /tokenwarden-report for savings, /tokenwarden-status for TUI status, /tokenwarden-account for your account, or /tokenwarden-connect to connect billing.",
+                        variant: "info",
+                    },
+                });
+            }
+            catch {
+                // Ignore missing TUI.
+            }
+        },
+        "command.execute.before": async (input) => {
+            if (isReportCommand(input.command)) {
+                await showReportToast(undefined, { force: true });
+                throw new Error("tokenwarden:handled");
+            }
+            if (isConnectCommand(input.command)) {
+                await showConnectToast();
+                throw new Error("tokenwarden:handled");
+            }
+            if (isStatusCommand(input.command)) {
+                await showStatusToast();
+                throw new Error("tokenwarden:handled");
+            }
+            if (isAccountCommand(input.command)) {
+                await showAccountToast();
+                throw new Error("tokenwarden:handled");
+            }
+            if (isDisconnectCommand(input.command)) {
+                await showDisconnectToast();
+                throw new Error("tokenwarden:handled");
+            }
+        },
+        "experimental.chat.system.transform": async (_input, output) => {
+            if (config.mode === "off")
+                return;
+            output.system.push([
+                "TokenWarden context policy:",
+                "Prefer smart_read or smart_pack before reading large source files raw.",
+                "When command output is large, preserve exact errors, file paths, line numbers, and failed test names before omitting noisy lines.",
+                "Use token_report when the user asks about token savings, would-have-used tokens, used tokens, or percentage saved.",
+                "TokenWarden response policy:",
+                "Use the shortest answer that can safely complete the user's development task.",
+                "Omit background, recap, praise, filler, and details that do not affect coding, debugging, verification, or planning.",
+                "Keep exact file paths, symbols, commands, errors, line numbers, failed tests, user decisions, and blockers when they affect future work.",
+                "Prefer bullets or short paragraphs. Do not restate tool output unless it changes the plan, explains a failure, or proves verification.",
+                "When reporting code work, include only changed behavior, files touched, verification run, blockers, and useful next steps.",
+                "If the user asks for detail, teaching, brainstorming, review, or a plan, provide the needed reasoning, but stay concise.",
+                "Balanced mode: include brief rationale only when it affects implementation or planning.",
+            ].join("\n"));
+        },
+        "experimental.chat.messages.transform": async (_input, output) => {
+            if (config.mode === "off")
+                return;
+            for (const message of output.messages) {
+                const sessionID = String(message.info.sessionID ?? "unknown");
+                for (const part of message.parts) {
+                    const key = findLargeTextKey(part);
+                    if (!key)
+                        continue;
+                    const reduced = reducePlainTextForContext({
+                        sessionID,
+                        label: String(part.type ?? "message-part"),
+                        text: String(part[key]),
+                        maxTokens: config.maxContextPartTokens,
+                    });
+                    if (!reduced)
+                        continue;
+                    part[key] = reduced.text;
+                    await engine.recordSavings(reduced.event);
+                }
+            }
+        },
+        "experimental.session.compacting": async (_input, output) => {
+            output.context.push([
+                "## TokenWarden continuation checklist",
+                "Preserve the current objective, relevant files, decisions already made, failed approaches, commands already run, test status, next actions, and anything the next agent must not forget.",
+                "Do not over-compress exact file paths, symbols, errors, or line numbers.",
+            ].join("\n"));
+        },
+        "tool.execute.after": async (input, output) => {
+            if (config.mode === "off")
+                return;
+            if (!output.output || typeof output.output !== "string")
+                return;
+            try {
+                const reduced = await engine.reduceToolOutput({
+                    sessionID: input.sessionID,
+                    callID: input.callID,
+                    tool: input.tool,
+                    args: input.args,
+                    output: output.output,
+                    maxTokens: config.maxToolOutputTokens,
+                });
+                output.output = reduced.output;
+                output.metadata = {
+                    ...(output.metadata ?? {}),
+                    tokenwarden: {
+                        wouldHaveUsedTokens: reduced.rawTokens,
+                        usedTokens: reduced.usedTokens,
+                        savedTokens: reduced.savedTokens,
+                        percentSaved: reduced.event.percentSaved,
+                        rawPath: reduced.rawPath,
+                    },
+                };
+                await engine.recordSavings(reduced.event);
+                await showSavingsToast(input.sessionID, reduced.savedTokens, reduced.event.percentSaved);
+            }
+            catch (error) {
+                await logFailure({
+                    stage: "tool.execute.after",
+                    sessionID: input.sessionID,
+                    callID: input.callID,
+                    tool: input.tool,
+                    error,
+                });
+                output.metadata = {
+                    ...(output.metadata ?? {}),
+                    tokenwarden: {
+                        error: error.message,
+                        skipped: true,
+                    },
+                };
+            }
+        },
+        tool: {
+            smart_read: tool({
+                description: "Read a source file in a token-efficient way. Returns symbols, exports, relevant blocks, or budgeted raw text and records would-have-used vs used token savings.",
+                args: {
+                    path: tool.schema.string().describe("Project-relative file path to read."),
+                    mode: tool.schema.enum(["symbols", "relevant", "summary", "raw-budgeted"]).optional(),
+                    query: tool.schema.string().optional().describe("Query for relevant mode, such as refresh token handling."),
+                    budget: tool.schema.number().int().positive().optional().describe("Maximum estimated tokens to return."),
+                },
+                async execute(args, context) {
+                    try {
+                        const result = await engine.smartRead({
+                            root: context.directory || directory,
+                            sessionID: context.sessionID,
+                            path: args.path,
+                            mode: args.mode,
+                            query: args.query,
+                            budget: args.budget,
+                        });
+                        await engine.recordSavings(result.event);
+                        await showSavingsToast(context.sessionID, result.event.savedTokens, result.event.percentSaved);
+                        return {
+                            title: `smart_read ${args.path}`,
+                            output: result.output,
+                            metadata: { tokenwarden: result.event },
+                        };
+                    }
+                    catch (error) {
+                        await logFailure({ stage: "tool.smart_read", sessionID: context.sessionID, tool: "smart_read", error });
+                        throw error;
+                    }
+                },
+            }),
+            smart_pack: tool({
+                description: "Pack multiple source files into a token budget using code structure instead of raw oversized file reads. Records would-have-used vs used token savings.",
+                args: {
+                    paths: tool.schema.array(tool.schema.string()).min(1).describe("Project-relative file paths or glob patterns."),
+                    query: tool.schema.string().optional().describe("Optional topic to focus relevant blocks."),
+                    budget: tool.schema.number().int().positive().optional().describe("Maximum estimated tokens to return."),
+                },
+                async execute(args, context) {
+                    try {
+                        const result = await engine.smartPack({
+                            root: context.directory || directory,
+                            sessionID: context.sessionID,
+                            paths: args.paths,
+                            query: args.query,
+                            budget: args.budget,
+                        });
+                        await engine.recordSavings(result.event);
+                        await showSavingsToast(context.sessionID, result.event.savedTokens, result.event.percentSaved);
+                        return {
+                            title: "smart_pack",
+                            output: result.output,
+                            metadata: { tokenwarden: result.event },
+                        };
+                    }
+                    catch (error) {
+                        await logFailure({ stage: "tool.smart_pack", sessionID: context.sessionID, tool: "smart_pack", error });
+                        throw error;
+                    }
+                },
+            }),
+            token_report: tool({
+                description: "Show TokenWarden token savings across all sessions: how many tokens would have been used, how many were used, tokens saved, and percentage saved. Uses red for would-have-used and green for saved values.",
+                args: {
+                    sessionID: tool.schema.string().optional().describe("Optional session id. Defaults to all locally recorded sessions."),
+                    color: tool.schema.boolean().optional().describe("Use ANSI colors. Defaults to true."),
+                },
+                async execute(args, context) {
+                    try {
+                        const summary = await engine.summarize(args.sessionID);
+                        return {
+                            title: "TokenWarden token report",
+                            output: formatTokenReport(summary, { color: args.color ?? true }),
+                            metadata: { tokenwarden: summary },
+                        };
+                    }
+                    catch (error) {
+                        await logFailure({ stage: "tool.token_report", sessionID: context.sessionID, tool: "token_report", error });
+                        throw error;
+                    }
+                },
+            }),
+        },
+    };
+};
+export default TokenWardenPlugin;
+function normalizeOptions(options) {
+    return {
+        maxToolOutputTokens: numberOption(options?.maxToolOutputTokens, DEFAULTS.maxToolOutputTokens),
+        maxContextPartTokens: numberOption(options?.maxContextPartTokens, DEFAULTS.maxContextPartTokens),
+        mode: options?.mode === "off" ? "off" : DEFAULTS.mode,
+        dataDir: typeof options?.dataDir === "string" ? options.dataDir : undefined,
+        showToasts: typeof options?.showToasts === "boolean" ? options.showToasts : DEFAULTS.showToasts,
+        showReportToastOnSessionIdle: typeof options?.showReportToastOnSessionIdle === "boolean"
+            ? options.showReportToastOnSessionIdle
+            : DEFAULTS.showReportToastOnSessionIdle,
+    };
+}
+function numberOption(value, fallback) {
+    return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : fallback;
+}
+function findLargeTextKey(part) {
+    for (const key of ["output", "text", "content"]) {
+        if (typeof part[key] === "string")
+            return key;
+    }
+    return undefined;
+}
+function sessionIDFromEvent(event) {
+    if (!event.properties || typeof event.properties !== "object")
+        return undefined;
+    const sessionID = event.properties.sessionID;
+    return typeof sessionID === "string" ? sessionID : undefined;
+}
+function accountPageURL(entitlement) {
+    const url = new URL("/account", tokenWardenSiteURL());
+    if (entitlement.monthlyCapTokens === null) {
+        url.searchParams.set("optimization", "unlimited");
+        return url.toString();
+    }
+    url.searchParams.set("remainingOptimizableTokens", String(entitlement.remainingFreeTokens ?? 0));
+    url.searchParams.set("monthlyOptimizedTokens", String(entitlement.monthlySavedTokens));
+    url.searchParams.set("monthlyCapTokens", String(entitlement.monthlyCapTokens));
+    return url.toString();
+}
+function openBrowser(url) {
+    const command = process.platform === "darwin" ? "open" : process.platform === "win32" ? "cmd" : "xdg-open";
+    const args = process.platform === "win32" ? ["/c", "start", "", url] : [url];
+    try {
+        const child = spawn(command, args, { detached: true, stdio: "ignore" });
+        child.unref();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/native/bin/tokenwarden-build-config.json

@@ -0,0 +1,4 @@
+{
+  "siteURL": "https://tokenwarden.ai/",
+  "generatedAt": "2026-06-11T13:05:49.344Z"
+}

package/native/bin/tokenwarden-engine-darwin-arm64.manifest.json

@@ -0,0 +1,17 @@
+{
+  "alg": "Ed25519",
+  "payload": {
+    "id": "tokenwarden-engine",
+    "version": "0.1.0",
+    "protocol": 1,
+    "binary": "tokenwarden-engine-darwin-arm64",
+    "platform": "darwin",
+    "arch": "arm64",
+    "sha256": "513d90c920758b1f758d2d99c39c459f133d736eb13e188916c1234c94f14076",
+    "builtAt": "2026-06-11T13:05:49.344Z",
+    "signingKey": "production-env",
+    "freeMonthlySavedTokenCap": 1000000,
+    "siteURL": "https://tokenwarden.ai/"
+  },
+  "signature": "ohu6u2V8MxAgOqsD9wTka9kfSgSLCjA5prmvxgK6WsTQoKm471WhcNteclSdGYrQQRVlqeJ0KXa3XRpXBUjmDg"
+}

package/native/bin/tokenwarden-engine-darwin-x64.manifest.json

@@ -0,0 +1,17 @@
+{
+  "alg": "Ed25519",
+  "payload": {
+    "id": "tokenwarden-engine",
+    "version": "0.1.0",
+    "protocol": 1,
+    "binary": "tokenwarden-engine-darwin-x64",
+    "platform": "darwin",
+    "arch": "x64",
+    "sha256": "ddba81a47b8bd308839765b04b1c48a837754b4074ff023ca96676019e8e3744",
+    "builtAt": "2026-06-11T13:05:49.344Z",
+    "signingKey": "production-env",
+    "freeMonthlySavedTokenCap": 1000000,
+    "siteURL": "https://tokenwarden.ai/"
+  },
+  "signature": "z3ztSkpcI06pn7z2U1RigF7tQEfsjlrXKSp-8guDC-EE8lU3X2MGNSNef8TiZb16BUnv_i8Sx6ZmX7GJ_k7ACA"
+}

package/native/bin/tokenwarden-engine-linux-arm64.manifest.json

@@ -0,0 +1,17 @@
+{
+  "alg": "Ed25519",
+  "payload": {
+    "id": "tokenwarden-engine",
+    "version": "0.1.0",
+    "protocol": 1,
+    "binary": "tokenwarden-engine-linux-arm64",
+    "platform": "linux",
+    "arch": "arm64",
+    "sha256": "06d9ad12796c9870a1a0515af08faa3e27fd1e4485b7c74bfd211ae32d617d7c",
+    "builtAt": "2026-06-11T13:05:49.344Z",
+    "signingKey": "production-env",
+    "freeMonthlySavedTokenCap": 1000000,
+    "siteURL": "https://tokenwarden.ai/"
+  },
+  "signature": "ixfSSTPk6pFKUyQFfcJrNLVybDxwxVojYix4QAYmpGrawkcvtt5JUzRsFCoLHxYPI5ysCIEiGNL9MO_7uKo8Cw"
+}

package/native/bin/tokenwarden-engine-linux-x64.manifest.json

@@ -0,0 +1,17 @@
+{
+  "alg": "Ed25519",
+  "payload": {
+    "id": "tokenwarden-engine",
+    "version": "0.1.0",
+    "protocol": 1,
+    "binary": "tokenwarden-engine-linux-x64",
+    "platform": "linux",
+    "arch": "x64",
+    "sha256": "92767449e681a41c62fc2f9f732ea3b17d8f99b0d66d42abbffcdf3f0bdff226",
+    "builtAt": "2026-06-11T13:05:49.344Z",
+    "signingKey": "production-env",
+    "freeMonthlySavedTokenCap": 1000000,
+    "siteURL": "https://tokenwarden.ai/"
+  },
+  "signature": "NiVRGdhL9C4CFh0ra8HqtCOmjzx6hU9QzIIySx5OWIyBnjft6LNnwCo02moBUYwH9Y9uofQxkiyW1zeb0RuLBA"
+}

package/native/bin/tokenwarden-engine-win32-x64.exe.manifest.json

@@ -0,0 +1,17 @@
+{
+  "alg": "Ed25519",
+  "payload": {
+    "id": "tokenwarden-engine",
+    "version": "0.1.0",
+    "protocol": 1,
+    "binary": "tokenwarden-engine-win32-x64.exe",
+    "platform": "win32",
+    "arch": "x64",
+    "sha256": "135c25f98391ea440bbc806f3b4085eec6beaa111f4ac6fa6758f9a0e99c5074",
+    "builtAt": "2026-06-11T13:05:49.344Z",
+    "signingKey": "production-env",
+    "freeMonthlySavedTokenCap": 1000000,
+    "siteURL": "https://tokenwarden.ai/"
+  },
+  "signature": "xSgOpISMvOIHfC5j-Af6B1We-wwRa5jLEYu6K7hhsCNclcMPUhfv6jk2SZWNs-Uf3t38DYoLDCmrBBUDsjoyDA"
+}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@tokenwarden/opencode",
+  "version": "0.1.0",
+  "description": "Local-first opencode cost and context control plugin.",
+  "type": "module",
+  "main": "dist/src/plugin/index.js",
+  "bin": {
+    "tokenwarden": "dist/src/cli/index.js"
+  },
+  "files": [
+    "dist/src",
+    "native/bin",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "npm run clean && npm run build:sidecar && npm run build:ts",
+    "build:sidecar": "node scripts/build-sidecar.mjs",
+    "build:ts": "tsc -p tsconfig.json",
+    "clean": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\"",
+    "prepublishOnly": "npm run verify:package",
+    "verify:package": "node scripts/verify-package-files.mjs",
+    "test": "npm run build && npm run test:built",
+    "test:built": "node --test dist/tests/*.test.js",
+    "report": "npm run build && node dist/src/cli/index.js report"
+  },
+  "dependencies": {
+    "@opencode-ai/plugin": "latest"
+  },
+  "devDependencies": {
+    "@types/node": "latest",
+    "typescript": "latest"
+  }
+}