@cjhyy/code-shell-core 0.7.1 → 0.8.0

package/dist/links/cli.js

@@ -0,0 +1,617 @@
+import { execFile } from "node:child_process";
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { asArray, asRecord, firstString, intParam, pathParam, pathSegmentParam, pick, stringParam, } from "./http.js";
+import { getLocalLinkProvider } from "./providers.js";
+const CONFIG = {
+    github: {
+        command: "gh",
+        hostname: "github.com",
+        statusArgs: ["auth", "status", "--active", "--hostname", "github.com"],
+        loginArgs: [
+            "auth",
+            "login",
+            "--hostname",
+            "github.com",
+            "--web",
+            "--clipboard",
+            "--git-protocol",
+            "https",
+            "--skip-ssh-key",
+        ],
+        tokenEnv: ["GH_TOKEN", "GITHUB_TOKEN", "GH_ENTERPRISE_TOKEN", "GITHUB_ENTERPRISE_TOKEN"],
+    },
+    gitlab: {
+        command: "glab",
+        hostname: "gitlab.com",
+        statusArgs: ["auth", "status", "--hostname", "gitlab.com"],
+        loginArgs: [
+            "auth",
+            "login",
+            "--hostname",
+            "gitlab.com",
+            "--web",
+            "--git-protocol",
+            "https",
+            "--use-keyring",
+        ],
+        tokenEnv: ["GITLAB_TOKEN", "GITLAB_ACCESS_TOKEN", "OAUTH_TOKEN", "CI_JOB_TOKEN"],
+    },
+    notion: {
+        command: "ntn",
+        statusArgs: ["--version"],
+        loginArgs: ["login"],
+        tokenEnv: ["NOTION_API_TOKEN"],
+    },
+    todoist: {
+        command: "td",
+        statusArgs: ["auth", "status", "--json"],
+        loginArgs: ["auth", "login", "--read-only", "--json"],
+        tokenEnv: ["TODOIST_API_TOKEN", "TODOIST_TOKEN"],
+    },
+    vercel: {
+        command: "vercel",
+        statusArgs: ["whoami", "--no-color"],
+        loginArgs: ["login", "--no-color"],
+        tokenEnv: ["VERCEL_TOKEN"],
+    },
+};
+const TOKEN_PATTERN = /\b(?:github_pat_|gh[pousr]_|glpat-|glcbt-|gldt-|ntn_|secret_)[A-Za-z0-9_.-]{6,}\b/gi;
+const MAX_OUTPUT_BYTES = 2 * 1024 * 1024;
+/** App-private CLI location. It never mutates the user's system PATH. */
+export function managedLinkCliPath(providerId) {
+    const base = process.env.CODESHELL_LINK_CLI_DIR ??
+        join(process.env.HOME ?? homedir(), ".code-shell", "tools", "link-cli");
+    const executable = `${CONFIG[providerId].command}${process.platform === "win32" ? ".exe" : ""}`;
+    return join(base, providerId, executable);
+}
+export function resolveLinkCliExecutable(providerId, fallbackCommand = CONFIG[providerId].command) {
+    const managed = managedLinkCliPath(providerId);
+    return existsSync(managed) ? managed : fallbackCommand;
+}
+function safeMessage(value) {
+    const stderr = value && typeof value === "object" && "stderr" in value
+        ? String(value.stderr ?? "").trim()
+        : "";
+    const raw = stderr || (value instanceof Error ? value.message : String(value ?? ""));
+    return raw.replace(TOKEN_PATTERN, "[redacted]").trim().slice(0, 500);
+}
+function isMissingExecutable(error) {
+    return Boolean(error &&
+        typeof error === "object" &&
+        "code" in error &&
+        error.code === "ENOENT");
+}
+export const runCliLinkCommand = (providerId, command, args, options) => new Promise((resolve, reject) => {
+    const env = { ...process.env };
+    for (const name of CONFIG[providerId].tokenEnv)
+        delete env[name];
+    const child = execFile(resolveLinkCliExecutable(providerId, command), args, {
+        cwd: options.cwd,
+        env,
+        encoding: "utf8",
+        timeout: options.timeoutMs,
+        maxBuffer: MAX_OUTPUT_BYTES,
+        windowsHide: true,
+        signal: options.signal,
+    }, (error, stdout, stderr) => {
+        if (error) {
+            Object.assign(error, { stdout, stderr });
+            reject(error);
+            return;
+        }
+        resolve({ stdout: String(stdout), stderr: String(stderr) });
+    });
+    // All supported flows are deliberately non-interactive (browser/device
+    // authorization or machine-readable API calls). Always close stdin so a
+    // CLI cannot mistake the Electron pipe for pending JSON or a hidden prompt.
+    child.stdin?.end(options.input ?? "");
+});
+function parseJson(result, providerId) {
+    try {
+        return JSON.parse(result.stdout);
+    }
+    catch {
+        throw new Error(`${providerId} CLI returned an invalid response`);
+    }
+}
+async function api(providerId, endpoint, options = {}, run = runCliLinkCommand) {
+    const config = CONFIG[providerId];
+    if (providerId === "todoist")
+        throw new Error("Todoist CLI does not expose a raw API command");
+    let args;
+    if (providerId === "github") {
+        args = ["api", endpoint, "--hostname", CONFIG.github.hostname];
+        if (options.method && options.method !== "GET")
+            args.push("--method", options.method);
+        if (options.input !== undefined)
+            args.push("--input", "-");
+    }
+    else if (providerId === "gitlab") {
+        args = ["api", endpoint, "--hostname", CONFIG.gitlab.hostname, "--output", "json"];
+        if (options.method && options.method !== "GET")
+            args.push("--method", options.method);
+        if (options.input !== undefined)
+            args.push("--input", "-");
+    }
+    else if (providerId === "notion") {
+        args = ["api", endpoint];
+        if (options.method && options.method !== "GET")
+            args.push("-X", options.method);
+    }
+    else {
+        args = ["api", endpoint, "--no-color"];
+        if (options.method && options.method !== "GET")
+            args.push("-X", options.method);
+    }
+    try {
+        const result = await run(providerId, config.command, args, {
+            cwd: options.cwd,
+            signal: options.signal,
+            timeoutMs: 30_000,
+            input: options.input === undefined ? undefined : JSON.stringify(options.input),
+        });
+        return parseJson(result, providerId);
+    }
+    catch (error) {
+        const message = safeMessage(error);
+        throw new Error(message || `${providerId} CLI request failed`, { cause: error });
+    }
+}
+function identityFromUser(providerId, data) {
+    const root = asRecord(data) ?? {};
+    const user = providerId === "vercel" ? (asRecord(root.user) ?? root) : root;
+    const externalAccountId = String(user.id ?? "account");
+    const label = (() => {
+        if (providerId === "github")
+            return firstString(user.login, user.name) ?? externalAccountId;
+        if (providerId === "gitlab")
+            return firstString(user.username, user.name) ?? externalAccountId;
+        if (providerId === "todoist") {
+            return firstString(user.email, user.fullName, user.name) ?? externalAccountId;
+        }
+        return firstString(user.name, user.username, user.email) ?? externalAccountId;
+    })();
+    const detail = firstString(user.name, user.email);
+    return { externalAccountId, label, ...(detail && detail !== label ? { detail } : {}) };
+}
+async function liveIdentity(providerId, options, run) {
+    if (providerId === "todoist") {
+        const status = parseJson(await run(providerId, CONFIG.todoist.command, CONFIG.todoist.statusArgs, {
+            ...options,
+            timeoutMs: 15_000,
+        }), providerId);
+        const identity = identityFromUser(providerId, status);
+        const projectRoot = asRecord(parseJson(await run(providerId, CONFIG.todoist.command, ["project", "list", "--json", "--limit", "12"], { ...options, timeoutMs: 30_000 }), providerId));
+        const resourceLabels = asArray(projectRoot?.results)
+            .map((value) => firstString(asRecord(value)?.name))
+            .filter((value) => Boolean(value))
+            .slice(0, 12);
+        return { ...identity, resourceLabels };
+    }
+    const userEndpoint = providerId === "notion" ? "v1/users/me" : providerId === "vercel" ? "/v2/user" : "user";
+    const user = await api(providerId, userEndpoint, options, run);
+    const identity = identityFromUser(providerId, user);
+    if (providerId === "notion")
+        return identity;
+    const resources = providerId === "github"
+        ? await api(providerId, "user/repos?per_page=12&sort=updated", options, run)
+        : providerId === "gitlab"
+            ? await api(providerId, "projects?membership=true&simple=true&per_page=12", options, run)
+            : await api(providerId, "/v10/projects?limit=12", options, run);
+    const resourceValues = providerId === "vercel" ? asArray(asRecord(resources)?.projects) : asArray(resources);
+    const resourceLabels = resourceValues
+        .map((value) => {
+        const record = asRecord(value);
+        return providerId === "github"
+            ? firstString(record?.full_name)
+            : providerId === "gitlab"
+                ? firstString(record?.path_with_namespace)
+                : firstString(record?.name);
+    })
+        .filter((value) => Boolean(value))
+        .slice(0, 12);
+    return { ...identity, resourceLabels };
+}
+async function currentIdentity(providerId, options, run) {
+    if (providerId === "todoist") {
+        return identityFromUser(providerId, parseJson(await run(providerId, CONFIG.todoist.command, CONFIG.todoist.statusArgs, {
+            ...options,
+            timeoutMs: 15_000,
+        }), providerId));
+    }
+    return identityFromUser(providerId, await api(providerId, providerId === "notion" ? "v1/users/me" : providerId === "vercel" ? "/v2/user" : "user", options, run));
+}
+/**
+ * A CLI may switch accounts after Link was connected. Pin every Action to the
+ * originally approved account so a local CLI change cannot silently widen or
+ * redirect the Link connection.
+ */
+export async function assertCliLinkAccount(providerId, expectedExternalAccountId, options = {}, run = runCliLinkCommand) {
+    const identity = await currentIdentity(providerId, options, run);
+    if (identity.externalAccountId !== expectedExternalAccountId) {
+        throw new Error(`${CONFIG[providerId].command} is signed in to a different account; reconnect this Link`);
+    }
+}
+export function isCliLinkProvider(providerId) {
+    return (providerId === "github" ||
+        providerId === "gitlab" ||
+        providerId === "notion" ||
+        providerId === "todoist" ||
+        providerId === "vercel");
+}
+export async function getCliLinkStatus(providerId, options = {}, run = runCliLinkCommand) {
+    const config = CONFIG[providerId];
+    try {
+        const statusResult = await run(providerId, config.command, config.statusArgs, {
+            ...options,
+            timeoutMs: 15_000,
+        });
+        const user = providerId === "todoist"
+            ? identityFromUser(providerId, parseJson(statusResult, providerId))
+            : await currentIdentity(providerId, options, run);
+        return {
+            providerId,
+            command: config.command,
+            installed: true,
+            authenticated: true,
+            account: user.label,
+        };
+    }
+    catch (error) {
+        if (isMissingExecutable(error)) {
+            return {
+                providerId,
+                command: config.command,
+                installed: false,
+                authenticated: false,
+                message: `${config.command} is not installed`,
+            };
+        }
+        return {
+            providerId,
+            command: config.command,
+            installed: true,
+            authenticated: false,
+            message: safeMessage(error) || `${config.command} is not signed in`,
+        };
+    }
+}
+export async function connectCliLink(providerId, options, run = runCliLinkCommand) {
+    let status = await getCliLinkStatus(providerId, options, run);
+    if (!status.installed)
+        throw new Error(`${status.command} is not installed`);
+    if (!status.authenticated && options.loginIfNeeded) {
+        const config = CONFIG[providerId];
+        try {
+            await run(providerId, config.command, config.loginArgs, {
+                cwd: options.cwd,
+                signal: options.signal,
+                timeoutMs: 15 * 60_000,
+            });
+        }
+        catch (error) {
+            throw new Error(safeMessage(error) || `${config.command} browser authorization failed`, {
+                cause: error,
+            });
+        }
+        status = await getCliLinkStatus(providerId, options, run);
+    }
+    if (!status.authenticated)
+        throw new Error(`${status.command} is not signed in`);
+    const provider = getLocalLinkProvider(providerId);
+    if (!provider)
+        throw new Error(`Unknown local Link provider: ${providerId}`);
+    return {
+        providerId,
+        identity: await liveIdentity(providerId, options, run),
+        capabilityIds: provider.actions.map((action) => `${providerId}.${action.id}`),
+        verifiedAt: new Date().toISOString(),
+    };
+}
+function compactList(data, keys, limit = 100) {
+    return asArray(data)
+        .slice(0, limit)
+        .map((value) => pick(value, keys));
+}
+function githubFile(data, owner, repo, ref) {
+    const record = asRecord(data) ?? {};
+    if (record.type !== "file")
+        throw new Error("GitHub path is not a file");
+    const encoded = typeof record.content === "string" ? record.content.replace(/\s/g, "") : "";
+    const content = encoded ? Buffer.from(encoded, "base64").toString("utf8").slice(0, 262_144) : "";
+    return {
+        owner,
+        repo,
+        path: record.path,
+        ...(ref ? { ref } : {}),
+        sha: record.sha,
+        size: record.size,
+        content,
+        truncated: typeof record.size === "number"
+            ? record.size > Buffer.byteLength(content)
+            : content.length >= 262_144,
+        html_url: record.html_url,
+    };
+}
+async function executeGithubCliAction(actionId, params, options, run) {
+    if (actionId === "list_repositories") {
+        const limit = intParam(params, "limit", 30, 100);
+        const data = await api("github", `user/repos?per_page=${limit}&sort=updated`, options, run);
+        return {
+            repositories: compactList(data, [
+                "id",
+                "full_name",
+                "description",
+                "private",
+                "archived",
+                "default_branch",
+                "html_url",
+                "updated_at",
+            ]),
+        };
+    }
+    // `gh api` resolves the endpoint against the REST base URL, so dot segments
+    // in argv would escape the fixed path template exactly like in a browser URL.
+    const owner = pathSegmentParam(params, "owner", { required: true, maxLength: 100 });
+    const repo = pathSegmentParam(params, "repo", { required: true, maxLength: 100 });
+    const base = `repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}`;
+    if (actionId === "get_readme") {
+        const result = githubFile(await api("github", `${base}/readme`, options, run), owner, repo);
+        return { ...result, size: undefined };
+    }
+    if (actionId === "get_file") {
+        const path = pathParam(params, "path", { required: true, maxLength: 2_000 });
+        const ref = stringParam(params, "ref", { maxLength: 300 });
+        const endpoint = `${base}/contents/${path}${ref ? `?ref=${encodeURIComponent(ref)}` : ""}`;
+        return githubFile(await api("github", endpoint, options, run), owner, repo, ref);
+    }
+    if (actionId === "list_issues") {
+        const limit = intParam(params, "limit", 30, 100);
+        const data = asArray(await api("github", `${base}/issues?per_page=${limit}`, options, run));
+        return {
+            issues: data
+                .filter((value) => !asRecord(value)?.pull_request)
+                .slice(0, 100)
+                .map((value) => pick(value, [
+                "number",
+                "title",
+                "state",
+                "html_url",
+                "created_at",
+                "updated_at",
+                "user",
+                "labels",
+            ])),
+        };
+    }
+    if (actionId === "list_pull_requests") {
+        const limit = intParam(params, "limit", 30, 100);
+        const data = await api("github", `${base}/pulls?per_page=${limit}`, options, run);
+        return {
+            pull_requests: compactList(data, [
+                "number",
+                "title",
+                "state",
+                "draft",
+                "html_url",
+                "created_at",
+                "updated_at",
+                "user",
+                "head",
+                "base",
+            ]),
+        };
+    }
+    if (actionId === "get_issue") {
+        const number = intParam(params, "issue_number", 0, Number.MAX_SAFE_INTEGER);
+        return pick(await api("github", `${base}/issues/${number}`, options, run), [
+            "number",
+            "title",
+            "body",
+            "state",
+            "state_reason",
+            "html_url",
+            "created_at",
+            "updated_at",
+            "closed_at",
+            "user",
+            "assignees",
+            "labels",
+            "milestone",
+            "comments",
+        ]);
+    }
+    if (actionId === "get_pull_request") {
+        const number = intParam(params, "pull_number", 0, Number.MAX_SAFE_INTEGER);
+        return pick(await api("github", `${base}/pulls/${number}`, options, run), [
+            "number",
+            "title",
+            "body",
+            "state",
+            "draft",
+            "merged",
+            "mergeable",
+            "html_url",
+            "created_at",
+            "updated_at",
+            "closed_at",
+            "merged_at",
+            "user",
+            "assignees",
+            "requested_reviewers",
+            "labels",
+            "head",
+            "base",
+            "commits",
+            "additions",
+            "deletions",
+            "changed_files",
+        ]);
+    }
+    if (actionId === "create_issue") {
+        const title = stringParam(params, "title", { required: true, maxLength: 256 });
+        const body = stringParam(params, "body", { maxLength: 20_000 });
+        const data = await api("github", `${base}/issues`, { ...options, method: "POST", input: { title, ...(body ? { body } : {}) } }, run);
+        return pick(data, ["number", "title", "state", "html_url", "created_at"]);
+    }
+    throw new Error(`Unknown GitHub CLI Link Action: ${actionId}`);
+}
+async function executeGitlabCliAction(actionId, params, options, run) {
+    const limit = intParam(params, "limit", 30, 100);
+    if (actionId === "list_projects") {
+        const data = await api("gitlab", `projects?membership=true&simple=true&per_page=${limit}`, options, run);
+        return {
+            projects: compactList(data, [
+                "id",
+                "name",
+                "path_with_namespace",
+                "description",
+                "visibility",
+                "default_branch",
+                "web_url",
+                "last_activity_at",
+            ]),
+        };
+    }
+    if (actionId === "list_issues") {
+        const data = await api("gitlab", `issues?scope=assigned_to_me&per_page=${limit}`, options, run);
+        return {
+            issues: compactList(data, [
+                "id",
+                "iid",
+                "project_id",
+                "title",
+                "state",
+                "web_url",
+                "created_at",
+                "updated_at",
+                "labels",
+            ]),
+        };
+    }
+    throw new Error(`Unknown GitLab CLI Link Action: ${actionId}`);
+}
+async function runJsonCommand(providerId, args, options, run) {
+    try {
+        return parseJson(await run(providerId, CONFIG[providerId].command, args, {
+            ...options,
+            timeoutMs: 30_000,
+        }), providerId);
+    }
+    catch (error) {
+        const message = safeMessage(error);
+        throw new Error(message || `${providerId} CLI request failed`, { cause: error });
+    }
+}
+async function executeNotionCliAction(actionId, params, options, run) {
+    if (actionId === "search") {
+        const query = stringParam(params, "query", { maxLength: 200 });
+        const data = asRecord(await api("notion", "v1/search", {
+            ...options,
+            method: "POST",
+            input: {
+                page_size: intParam(params, "limit", 30, 100),
+                ...(query ? { query } : {}),
+            },
+        }, run)) ?? {};
+        return {
+            results: asArray(data.results)
+                .slice(0, 100)
+                .map((value) => pick(value, [
+                "object",
+                "id",
+                "url",
+                "created_time",
+                "last_edited_time",
+                "archived",
+                "parent",
+                "properties",
+                "title",
+            ])),
+            has_more: data.has_more,
+            next_cursor: data.next_cursor,
+        };
+    }
+    if (actionId === "get_page") {
+        const pageId = pathSegmentParam(params, "page_id", { required: true, maxLength: 100 });
+        return pick(await api("notion", `v1/pages/${encodeURIComponent(pageId)}`, options, run), [
+            "object",
+            "id",
+            "url",
+            "created_time",
+            "last_edited_time",
+            "archived",
+            "parent",
+            "properties",
+        ]);
+    }
+    throw new Error(`Unknown Notion CLI Link Action: ${actionId}`);
+}
+function todoistProject(value) {
+    const project = asRecord(value) ?? {};
+    return {
+        ...pick(project, ["id", "name", "description", "color", "url"]),
+        ...(typeof project.isFavorite === "boolean" ? { is_favorite: project.isFavorite } : {}),
+        ...(typeof project.parentId === "string" ? { parent_id: project.parentId } : {}),
+        ...(typeof project.workspaceId === "string" ? { workspace_id: project.workspaceId } : {}),
+    };
+}
+function todoistTask(value) {
+    const task = asRecord(value) ?? {};
+    return {
+        ...pick(task, ["id", "content", "description", "priority", "due", "labels", "url"]),
+        ...(typeof task.projectId === "string" ? { project_id: task.projectId } : {}),
+        ...(typeof task.sectionId === "string" ? { section_id: task.sectionId } : {}),
+        ...(typeof task.parentId === "string" ? { parent_id: task.parentId } : {}),
+    };
+}
+async function executeTodoistCliAction(actionId, params, options, run) {
+    const limit = intParam(params, "limit", actionId === "list_tasks" ? 50 : 30, 100);
+    if (actionId === "list_projects") {
+        const root = asRecord(await runJsonCommand("todoist", ["project", "list", "--json", "--limit", String(limit)], options, run)) ?? {};
+        return { projects: asArray(root.results).slice(0, 100).map(todoistProject) };
+    }
+    if (actionId === "list_tasks") {
+        const root = asRecord(await runJsonCommand("todoist", ["task", "list", "--json", "--limit", String(limit)], options, run)) ?? {};
+        return {
+            tasks: asArray(root.results).slice(0, 100).map(todoistTask),
+            next_cursor: root.nextCursor,
+        };
+    }
+    throw new Error(`Unknown Todoist CLI Link Action: ${actionId}`);
+}
+async function executeVercelCliAction(actionId, params, options, run) {
+    const limit = intParam(params, "limit", 50, 100);
+    const teamId = stringParam(params, "team_id", { maxLength: 100 });
+    const query = new URLSearchParams({ limit: String(limit) });
+    if (teamId)
+        query.set("teamId", teamId);
+    if (actionId === "list_projects") {
+        const root = asRecord(await api("vercel", `/v10/projects?${query}`, options, run)) ?? {};
+        return {
+            projects: compactList(root.projects, ["id", "name", "framework", "updatedAt", "createdAt", "latestDeployments"], 100),
+            pagination: root.pagination,
+        };
+    }
+    if (actionId === "list_deployments") {
+        const root = asRecord(await api("vercel", `/v7/deployments?${query}`, options, run)) ?? {};
+        return {
+            deployments: compactList(root.deployments, ["uid", "name", "url", "state", "target", "created", "ready", "meta"], 100),
+            pagination: root.pagination,
+        };
+    }
+    throw new Error(`Unknown Vercel CLI Link Action: ${actionId}`);
+}
+export async function executeCliLinkAction(providerId, actionId, params, options = {}, run = runCliLinkCommand) {
+    if (providerId === "github")
+        return executeGithubCliAction(actionId, params, options, run);
+    if (providerId === "gitlab")
+        return executeGitlabCliAction(actionId, params, options, run);
+    if (providerId === "notion")
+        return executeNotionCliAction(actionId, params, options, run);
+    if (providerId === "todoist")
+        return executeTodoistCliAction(actionId, params, options, run);
+    return executeVercelCliAction(actionId, params, options, run);
+}

package/dist/links/http.d.ts

@@ -0,0 +1,40 @@
+export interface LinkHttpRequest {
+    url: URL;
+    method?: "GET" | "POST";
+    headers: Record<string, string>;
+    body?: unknown;
+    signal?: AbortSignal;
+    fetchImpl?: typeof fetch;
+}
+export declare function linkRequestJson(request: LinkHttpRequest): Promise<unknown>;
+export declare function asRecord(value: unknown): Record<string, unknown> | undefined;
+export declare function asArray(value: unknown): unknown[];
+export declare function firstString(...values: unknown[]): string | undefined;
+export declare function stringParam(params: Record<string, unknown>, key: string, options?: {
+    required?: boolean;
+    maxLength?: number;
+}): string | undefined;
+/**
+ * Values interpolated into a fixed URL path template must never move the
+ * request to another endpoint. `encodeURIComponent` does not neutralize
+ * `.`/`..`, and both `new URL()` and CLI backends like `gh api` normalize dot
+ * segments away, so `organization: ".."` would otherwise turn
+ * `/organizations/../projects/` into `/projects/`.
+ */
+export declare function assertPathSegment(value: string, key: string): string;
+/** A string param used as exactly one segment of a URL path template. */
+export declare function pathSegmentParam(params: Record<string, unknown>, key: string, options?: {
+    required?: boolean;
+    maxLength?: number;
+}): string | undefined;
+/**
+ * A slash-separated resource path (e.g. a file path inside a repository).
+ * Every segment is validated like assertPathSegment and encoded individually;
+ * the returned string is ready to interpolate into a URL path template.
+ */
+export declare function pathParam(params: Record<string, unknown>, key: string, options?: {
+    required?: boolean;
+    maxLength?: number;
+}): string | undefined;
+export declare function intParam(params: Record<string, unknown>, key: string, fallback: number, max: number): number;
+export declare function pick(record: unknown, keys: readonly string[]): Record<string, unknown>;