shakerscan-cli 0.1.0

package/README.md

@@ -0,0 +1,40 @@
+# Shaker CLI
+
+First-party command-line interface for the Shaker Scan control plane.
+
+Install from npm:
+
+```bash
+npm install -g shakerscan-cli
+shaker --help
+```
+
+Or run it without installing:
+
+```bash
+npx shakerscan-cli --help
+```
+
+Current commands:
+
+- `usage`
+- `scan submit`
+- `scan status`
+- `scan wait`
+- `findings`
+- `verify`
+- `policy eval`
+- `evidence get`
+- `approval-token issue`
+- `approval-token verify`
+- `remediation request`
+- `remediation get`
+- `gate`
+
+Local usage from this repo:
+
+```bash
+cd scanner-app
+npm run build:cli
+npm run cli -- gate --target https://example.com --scan-type preview --environment preview --policy-pack preview-fast --approval-token true
+```

package/dist/index.js

@@ -0,0 +1,669 @@
+#!/usr/bin/env node
+class CliError extends Error {
+    exitCode;
+    constructor(message, exitCode = 1) {
+        super(message);
+        this.name = 'CliError';
+        this.exitCode = exitCode;
+    }
+}
+class HttpError extends Error {
+    status;
+    body;
+    constructor(status, body) {
+        super(`HTTP ${status}: ${body}`);
+        this.name = 'HttpError';
+        this.status = status;
+        this.body = body;
+    }
+}
+class ShakerClient {
+    baseUrl;
+    apiKey;
+    constructor(baseUrl, apiKey) {
+        this.baseUrl = baseUrl;
+        this.apiKey = apiKey;
+    }
+    get headers() {
+        return {
+            'Content-Type': 'application/json',
+            'X-API-Key': this.apiKey,
+        };
+    }
+    async request(path, init) {
+        const response = await fetch(`${this.baseUrl}${path}`, {
+            ...init,
+            headers: {
+                ...this.headers,
+                ...(init?.headers || {}),
+            },
+        });
+        if (!response.ok) {
+            throw new HttpError(response.status, await response.text());
+        }
+        return (await response.json());
+    }
+    submitScan(target, input) {
+        return this.request('/api/v1/scan', {
+            method: 'POST',
+            body: JSON.stringify({
+                target,
+                scan_type: input.scanType,
+                options: input.options || {},
+            }),
+        });
+    }
+    getScan(scanId) {
+        return this.request(`/api/v1/scan?id=${encodeURIComponent(scanId)}`);
+    }
+    getFindings(scanId, severity, limit = 200, offset = 0) {
+        const params = new URLSearchParams({
+            scan_id: scanId,
+            limit: String(limit),
+            offset: String(offset),
+        });
+        if (severity) {
+            params.set('severity', severity);
+        }
+        return this.request(`/api/v1/findings?${params.toString()}`);
+    }
+    verifyFinding(findingId) {
+        return this.request(`/api/v1/findings/${encodeURIComponent(findingId)}/verify`, {
+            method: 'POST',
+        });
+    }
+    evaluatePolicy(scanId, environment, policyPack) {
+        return this.request('/api/v1/policy/evaluate', {
+            method: 'POST',
+            body: JSON.stringify({ scan_id: scanId, environment, policy_pack: policyPack }),
+        });
+    }
+    getEvidence(evidenceId) {
+        return this.request(`/api/v1/evidence/${encodeURIComponent(evidenceId)}`);
+    }
+    issueApprovalToken(evidenceId, options) {
+        return this.request(`/api/v1/evidence/${encodeURIComponent(evidenceId)}/token`, {
+            method: 'POST',
+            body: JSON.stringify({
+                ttl_seconds: options.ttlSeconds,
+                audience: options.audience,
+            }),
+        });
+    }
+    verifyApprovalToken(token, audience) {
+        return this.request('/api/v1/approval-tokens/verify', {
+            method: 'POST',
+            body: JSON.stringify({
+                token,
+                audience,
+            }),
+        });
+    }
+    requestRemediation(findingId, options) {
+        return this.request(`/api/v1/findings/${encodeURIComponent(findingId)}/remediate`, {
+            method: 'POST',
+            body: JSON.stringify({
+                policy_evaluation_id: options.policyEvaluationId,
+                notes: options.notes,
+            }),
+        });
+    }
+    getRemediation(remediationJobId) {
+        return this.request(`/api/v1/remediation/${encodeURIComponent(remediationJobId)}`);
+    }
+    getUsage() {
+        return this.request('/api/v1/usage');
+    }
+}
+function parseArgs(argv) {
+    const positionals = [];
+    const flags = new Map();
+    for (let index = 0; index < argv.length; index += 1) {
+        const token = argv[index];
+        if (!token.startsWith('--')) {
+            positionals.push(token);
+            continue;
+        }
+        const flag = token.slice(2);
+        const next = argv[index + 1];
+        if (!next || next.startsWith('--')) {
+            flags.set(flag, true);
+            continue;
+        }
+        flags.set(flag, next);
+        index += 1;
+    }
+    return { positionals, flags };
+}
+function getFlag(args, name) {
+    return args.flags.get(name);
+}
+function getString(args, name, fallback) {
+    const value = getFlag(args, name);
+    if (typeof value === 'string')
+        return value;
+    if (value === true)
+        return 'true';
+    return fallback;
+}
+function getBoolean(args, name, fallback = false) {
+    const value = getFlag(args, name);
+    if (value === undefined)
+        return fallback;
+    if (typeof value === 'boolean')
+        return value;
+    return value === 'true' || value === '1' || value === 'yes';
+}
+function hasFlag(args, name) {
+    return args.flags.has(name);
+}
+function getOptionalBoolean(args, name) {
+    if (!hasFlag(args, name))
+        return undefined;
+    return getBoolean(args, name);
+}
+function getNumber(args, name, fallback) {
+    const value = getString(args, name);
+    if (value === undefined)
+        return fallback;
+    const parsed = Number(value);
+    if (Number.isNaN(parsed)) {
+        throw new CliError(`Invalid value for --${name}: ${value}`);
+    }
+    return parsed;
+}
+function requireString(args, name) {
+    const value = getString(args, name);
+    if (!value) {
+        throw new CliError(`Missing required flag --${name}`);
+    }
+    return value;
+}
+function resolveClient(args) {
+    const apiKey = getString(args, 'api-key') || process.env.SHAKER_API_KEY || process.env.SCANNER_API_KEY;
+    if (!apiKey) {
+        throw new CliError('Set SHAKER_API_KEY or pass --api-key');
+    }
+    const baseUrl = getString(args, 'base-url') ||
+        process.env.SHAKER_BASE_URL ||
+        process.env.SCANNER_API_URL ||
+        'https://shakerscan.com';
+    return new ShakerClient(baseUrl.replace(/\/$/, ''), apiKey);
+}
+const VALID_SCAN_TYPES = ['sandbox', 'preview', 'standard', 'complete', 'full'];
+function getScanTypeArg(args, fallback) {
+    const value = getString(args, 'scan-type');
+    if (value === undefined)
+        return fallback;
+    const normalized = value.trim().toLowerCase();
+    if (!VALID_SCAN_TYPES.includes(normalized)) {
+        throw new CliError(`Invalid --scan-type. Use one of: ${VALID_SCAN_TYPES.join(', ')}`);
+    }
+    return normalized;
+}
+function buildScanOptions(args) {
+    const options = {};
+    const quick = getOptionalBoolean(args, 'quick');
+    const isPublic = getOptionalBoolean(args, 'public');
+    const active = getOptionalBoolean(args, 'active');
+    if (quick !== undefined)
+        options.quick = quick;
+    if (isPublic !== undefined)
+        options.public = isPublic;
+    if (active !== undefined)
+        options.active = active;
+    return options;
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function severityCounts(findings) {
+    const counts = {
+        critical: 0,
+        high: 0,
+        medium: 0,
+        low: 0,
+        info: 0,
+    };
+    for (const finding of findings) {
+        counts[finding.severity] += 1;
+    }
+    return counts;
+}
+function print(data) {
+    process.stdout.write(`${JSON.stringify(data, null, 2)}\n`);
+}
+function shellQuote(value) {
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function formatRemediationHandoff(remediation, format) {
+    const prDraft = remediation.artifact.pr_draft;
+    const patchSuggestion = remediation.artifact.patch_suggestion;
+    if (format === 'shell') {
+        return [
+            `git checkout -b ${shellQuote(prDraft.branch_name)}`,
+            '',
+            '# Apply the suggested changes below, then open a PR:',
+            ...patchSuggestion.changes.map((entry) => `# - ${entry}`),
+            '',
+            `gh pr create --title ${shellQuote(prDraft.title)} --body ${shellQuote(prDraft.body_markdown)}`,
+        ].join('\n');
+    }
+    return [
+        `# ${prDraft.title}`,
+        '',
+        `Branch: \`${prDraft.branch_name}\``,
+        remediation.artifact.target_url ? `Target: ${remediation.artifact.target_url}` : '',
+        '',
+        `## Summary`,
+        prDraft.summary,
+        '',
+        `## Patch suggestion`,
+        patchSuggestion.approach,
+        '',
+        `### Candidate locations`,
+        ...patchSuggestion.candidate_locations.map((entry) => `- ${entry}`),
+        '',
+        `### Example changes`,
+        ...patchSuggestion.changes.map((entry) => `- ${entry}`),
+        '',
+        prDraft.body_markdown,
+    ]
+        .filter(Boolean)
+        .join('\n');
+}
+function nextStep(decision) {
+    switch (decision) {
+        case 'allow':
+            return 'continue';
+        case 'block':
+            return 'fix_and_retry';
+        default:
+            return 'request_approval_or_fix';
+    }
+}
+function fallbackDecision(findings) {
+    const counts = severityCounts(findings);
+    if (counts.critical > 0)
+        return 'block';
+    if (counts.high > 0)
+        return 'needs_approval';
+    return 'allow';
+}
+async function waitForCompletion(client, scanId, intervalSeconds, timeoutSeconds) {
+    const deadline = Date.now() + timeoutSeconds * 1000;
+    while (Date.now() < deadline) {
+        const scan = await client.getScan(scanId);
+        if (scan.status === 'completed' || scan.status === 'failed') {
+            return scan;
+        }
+        await sleep(intervalSeconds * 1000);
+    }
+    throw new CliError(`Timed out waiting for scan ${scanId}`, 1);
+}
+async function handleUsage(args) {
+    const client = resolveClient(args);
+    print(await client.getUsage());
+}
+async function handleScan(args) {
+    const client = resolveClient(args);
+    const subcommand = args.positionals[1];
+    if (subcommand === 'submit') {
+        const target = requireString(args, 'target');
+        print(await client.submitScan(target, {
+            scanType: getScanTypeArg(args),
+            options: buildScanOptions(args),
+        }));
+        return;
+    }
+    if (subcommand === 'status') {
+        print(await client.getScan(requireString(args, 'scan-id')));
+        return;
+    }
+    if (subcommand === 'wait') {
+        const scanId = requireString(args, 'scan-id');
+        print(await waitForCompletion(client, scanId, getNumber(args, 'interval', 5), getNumber(args, 'timeout', 300)));
+        return;
+    }
+    throw new CliError('Usage: shaker scan <submit|status|wait> [flags]');
+}
+async function handleFindings(args) {
+    const client = resolveClient(args);
+    print(await client.getFindings(requireString(args, 'scan-id'), getString(args, 'severity'), getNumber(args, 'limit', 200), getNumber(args, 'offset', 0)));
+}
+async function handleVerify(args) {
+    const client = resolveClient(args);
+    print(await client.verifyFinding(requireString(args, 'finding-id')));
+}
+async function handlePolicy(args) {
+    const client = resolveClient(args);
+    const subcommand = args.positionals[1];
+    if (subcommand !== 'eval') {
+        throw new CliError('Usage: shaker policy eval --scan-id <id> [--environment preview] [--policy-pack default]');
+    }
+    print(await client.evaluatePolicy(requireString(args, 'scan-id'), getString(args, 'environment', 'preview') || 'preview', getString(args, 'policy-pack')));
+}
+async function handleEvidence(args) {
+    const client = resolveClient(args);
+    const subcommand = args.positionals[1];
+    if (subcommand !== 'get') {
+        throw new CliError('Usage: shaker evidence get --evidence-id <id>');
+    }
+    print(await client.getEvidence(requireString(args, 'evidence-id')));
+}
+async function handleApprovalToken(args) {
+    const client = resolveClient(args);
+    const subcommand = args.positionals[1];
+    if (subcommand === 'issue') {
+        print(await client.issueApprovalToken(requireString(args, 'evidence-id'), {
+            ttlSeconds: getNumber(args, 'ttl', 900),
+            audience: getString(args, 'audience'),
+        }));
+        return;
+    }
+    if (subcommand === 'verify') {
+        print(await client.verifyApprovalToken(requireString(args, 'token'), getString(args, 'audience')));
+        return;
+    }
+    throw new CliError('Usage: shaker approval-token <issue|verify> [--evidence-id <id>] [--token <token>]');
+}
+async function handleRemediation(args) {
+    const client = resolveClient(args);
+    const subcommand = args.positionals[1];
+    if (subcommand === 'request') {
+        print(await client.requestRemediation(requireString(args, 'finding-id'), {
+            policyEvaluationId: getString(args, 'policy-evaluation-id'),
+            notes: getString(args, 'notes'),
+        }));
+        return;
+    }
+    if (subcommand === 'get') {
+        print(await client.getRemediation(requireString(args, 'remediation-job-id')));
+        return;
+    }
+    if (subcommand === 'handoff') {
+        const remediation = await client.getRemediation(requireString(args, 'remediation-job-id'));
+        const format = getString(args, 'format', 'markdown');
+        if (format !== 'markdown' && format !== 'shell') {
+            throw new CliError('Invalid --format. Use markdown or shell.');
+        }
+        process.stdout.write(`${formatRemediationHandoff(remediation, format)}\n`);
+        return;
+    }
+    throw new CliError('Usage: shaker remediation <request|get|handoff> [flags]');
+}
+async function handleGate(args) {
+    const client = resolveClient(args);
+    const target = getString(args, 'target');
+    const existingScanId = getString(args, 'scan-id');
+    if (!target && !existingScanId) {
+        throw new CliError('Pass --target or --scan-id to gate');
+    }
+    let scan;
+    if (existingScanId) {
+        scan = await waitForCompletion(client, existingScanId, getNumber(args, 'interval', 5), getNumber(args, 'timeout', 300));
+    }
+    else {
+        const submitted = await client.submitScan(target, {
+            scanType: getScanTypeArg(args, 'preview'),
+            options: buildScanOptions(args),
+        });
+        scan = await waitForCompletion(client, submitted.scan_id, getNumber(args, 'interval', 5), getNumber(args, 'timeout', 300));
+    }
+    if (scan.status !== 'completed') {
+        const result = {
+            status: 'error',
+            scan_id: scan.scan_id,
+            reason: `scan_${scan.status}`,
+        };
+        print(result);
+        process.exitCode = 1;
+        return;
+    }
+    const findingsResponse = await client.getFindings(scan.scan_id, undefined, getNumber(args, 'limit', 200), 0);
+    const findings = findingsResponse.findings;
+    const counts = severityCounts(findings);
+    const verifySet = new Set((getString(args, 'verify-severities', 'critical,high') || 'critical,high')
+        .split(',')
+        .map((value) => value.trim())
+        .filter(Boolean));
+    const verificationCandidates = findings.filter((finding) => verifySet.has(finding.severity));
+    const verifications = [];
+    const verificationErrors = [];
+    for (const finding of verificationCandidates) {
+        try {
+            verifications.push(await client.verifyFinding(finding.id));
+        }
+        catch (error) {
+            verificationErrors.push({
+                finding_id: finding.id,
+                error: error instanceof Error ? error.message : 'Unknown verification error',
+            });
+        }
+    }
+    let policy = null;
+    let evidence = null;
+    let approvalToken = null;
+    let decisionSource = 'policy_api';
+    let decision;
+    let rationale;
+    try {
+        policy = await client.evaluatePolicy(scan.scan_id, getString(args, 'environment', 'preview') || 'preview', getString(args, 'policy-pack'));
+        evidence = await client.getEvidence(policy.evidence_id);
+        decision = policy.decision;
+        rationale = policy.rationale;
+    }
+    catch (error) {
+        if (!(error instanceof HttpError) || (error.status !== 403 && error.status !== 404)) {
+            throw error;
+        }
+        decisionSource = 'fallback';
+        decision = fallbackDecision(findings);
+        rationale =
+            decision === 'block'
+                ? 'Fallback gate blocked because at least one critical finding exists.'
+                : decision === 'needs_approval'
+                    ? 'Fallback gate requires approval because high findings exist.'
+                    : 'Fallback gate allowed because no critical or high findings exist.';
+    }
+    const remediationLimit = getNumber(args, 'remediation-limit', 1);
+    const createRemediation = getBoolean(args, 'remediation', true);
+    const remediationJobs = [];
+    if (createRemediation && remediationLimit > 0 && decision !== 'allow') {
+        const candidates = findings
+            .filter((finding) => finding.severity === 'critical' || finding.severity === 'high')
+            .slice(0, remediationLimit);
+        for (const finding of candidates) {
+            try {
+                remediationJobs.push(await client.requestRemediation(finding.id, {
+                    policyEvaluationId: policy?.evaluation_id,
+                    notes: getString(args, 'remediation-notes', `CLI gate for ${scan.scan_id}`),
+                }));
+            }
+            catch (error) {
+                verificationErrors.push({
+                    finding_id: finding.id,
+                    error: error instanceof Error ? error.message : 'Unknown remediation error',
+                });
+            }
+        }
+    }
+    if (getBoolean(args, 'approval-token', false) &&
+        decision === 'allow' &&
+        policy?.evidence_id &&
+        evidence?.approval_token?.supported &&
+        evidence.approval_token.eligible) {
+        approvalToken = await client.issueApprovalToken(policy.evidence_id, {
+            ttlSeconds: getNumber(args, 'approval-token-ttl', 900),
+            audience: getString(args, 'approval-token-audience'),
+        });
+    }
+    const summary = {
+        command: 'gate',
+        decision,
+        decision_source: decisionSource,
+        next_step: nextStep(decision),
+        scan_id: scan.scan_id,
+        target: scan.target,
+        scan_status: scan.status,
+        environment: getString(args, 'environment', 'preview'),
+        policy_pack: getString(args, 'policy-pack', 'default'),
+        findings: {
+            total: findingsResponse.summary.total,
+            by_severity: counts,
+        },
+        verifications: {
+            attempted: verificationCandidates.length,
+            completed: verifications.length,
+            errors: verificationErrors,
+            artifacts: verifications.map((artifact) => ({
+                verification_id: artifact.verification_id,
+                finding_id: artifact.finding_id,
+                status: artifact.status,
+                confidence: artifact.confidence,
+            })),
+        },
+        policy: policy
+            ? {
+                evaluation_id: policy.evaluation_id,
+                policy_pack: policy.policy_pack || null,
+                evidence_id: policy.evidence_id,
+                decision: policy.decision,
+                rationale: policy.rationale,
+                approval_token: policy.approval_token || null,
+            }
+            : {
+                evaluation_id: null,
+                evidence_id: null,
+                decision,
+                rationale,
+            },
+        evidence: evidence
+            ? {
+                id: evidence.id,
+                kind: evidence.kind,
+                evidence_hash: evidence.evidence_hash,
+                approval_token: evidence.approval_token || null,
+                exception: evidence.exception || null,
+            }
+            : null,
+        approval_token: approvalToken
+            ? {
+                token_type: approvalToken.token_type,
+                token: approvalToken.token,
+                issued_at: approvalToken.issued_at,
+                expires_at: approvalToken.expires_at,
+                audience: approvalToken.audience,
+                evidence_id: approvalToken.evidence_id,
+            }
+            : null,
+        remediation: remediationJobs.map((job) => ({
+            remediation_job_id: job.remediation_job_id,
+            finding_id: job.finding_id,
+            status: job.status,
+            artifact_hash: job.artifact_hash,
+            family: job.artifact.family,
+            patch_suggestion: {
+                approach: job.artifact.patch_suggestion.approach,
+                candidate_locations: job.artifact.patch_suggestion.candidate_locations,
+            },
+            pr_draft: {
+                title: job.artifact.pr_draft.title,
+                branch_name: job.artifact.pr_draft.branch_name,
+                summary: job.artifact.pr_draft.summary,
+            },
+        })),
+    };
+    print(summary);
+    process.exitCode = decision === 'allow' ? 0 : decision === 'block' ? 10 : 20;
+}
+function help() {
+    const output = [
+        'Shaker CLI',
+        '',
+        'Environment:',
+        '  SHAKER_API_KEY or SCANNER_API_KEY',
+        '  SHAKER_BASE_URL or SCANNER_API_URL (default https://shakerscan.com)',
+        '',
+        'Commands:',
+        '  shaker usage',
+        '  shaker scan submit --target <url> [--scan-type preview|sandbox|standard|complete|full]',
+        '  shaker scan status --scan-id <id>',
+        '  shaker scan wait --scan-id <id> [--interval 5] [--timeout 300]',
+        '  shaker findings --scan-id <id> [--severity high] [--limit 200]',
+        '  shaker verify --finding-id <id>',
+        '  shaker policy eval --scan-id <id> [--environment preview] [--policy-pack default]',
+        '  shaker evidence get --evidence-id <id>',
+        '  shaker approval-token issue --evidence-id <id> [--ttl 900] [--audience github-actions]',
+        '  shaker approval-token verify --token <token> [--audience github-actions]',
+        '  shaker remediation request --finding-id <id> [--policy-evaluation-id <id>] [--notes text]',
+        '  shaker remediation get --remediation-job-id <id>',
+        '  shaker remediation handoff --remediation-job-id <id> [--format markdown|shell]',
+        '  shaker gate --target <url> [--scan-type preview|sandbox|standard|complete|full] [--environment preview] [--policy-pack default] [--approval-token true]',
+        '',
+        'Gate exit codes:',
+        '  0 allow',
+        '  10 block',
+        '  20 needs_approval',
+        '  1 error',
+    ];
+    process.stdout.write(`${output.join('\n')}\n`);
+}
+async function main() {
+    const args = parseArgs(process.argv.slice(2));
+    const command = args.positionals[0];
+    if (!command || command === 'help' || getBoolean(args, 'help')) {
+        help();
+        return;
+    }
+    if (command === 'usage') {
+        await handleUsage(args);
+        return;
+    }
+    if (command === 'scan') {
+        await handleScan(args);
+        return;
+    }
+    if (command === 'findings') {
+        await handleFindings(args);
+        return;
+    }
+    if (command === 'verify') {
+        await handleVerify(args);
+        return;
+    }
+    if (command === 'policy') {
+        await handlePolicy(args);
+        return;
+    }
+    if (command === 'evidence') {
+        await handleEvidence(args);
+        return;
+    }
+    if (command === 'approval-token') {
+        await handleApprovalToken(args);
+        return;
+    }
+    if (command === 'remediation') {
+        await handleRemediation(args);
+        return;
+    }
+    if (command === 'gate') {
+        await handleGate(args);
+        return;
+    }
+    throw new CliError(`Unknown command: ${command}`);
+}
+main().catch((error) => {
+    if (error instanceof CliError) {
+        process.stderr.write(`${error.message}\n`);
+        process.exit(error.exitCode);
+    }
+    if (error instanceof HttpError) {
+        process.stderr.write(`${error.message}\n`);
+        process.exit(1);
+    }
+    process.stderr.write(`${error instanceof Error ? error.stack || error.message : String(error)}\n`);
+    process.exit(1);
+});
+export {};

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "shakerscan-cli",
+  "version": "0.1.0",
+  "description": "First-party CLI for the ShakerScan security control plane",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "shaker": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "start": "node dist/index.js",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "shakerscan",
+    "security",
+    "scanner",
+    "dast",
+    "cli",
+    "devsecops"
+  ],
+  "author": "ShakerScan",
+  "license": "MIT",
+  "homepage": "https://shakerscan.com",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/andriyze/scanner"
+  },
+  "bugs": {
+    "url": "https://github.com/andriyze/scanner/issues"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@types/node": "^20",
+    "typescript": "^5"
+  }
+}