net-snmp 3.26.1 → 3.26.2

package/.claude/skills/git-commit/SKILL.md

@@ -0,0 +1,54 @@
+---
+name: git-commit
+description: Creates a git commit summarizing all current working tree changes (staged and unstaged). Use when the user asks to commit, save progress, or invoke /git-commit.
+---
+
+# Git Commit
+
+## When to use
+
+- When the user asks to commit current changes.
+- When invoked via `/git-commit`.
+
+## Arguments
+
+- `dry-run` — perform steps 1–3 only (gather context, identify files, draft commit message) and then **ask the user** whether to proceed with the actual commit or cancel. Do **not** stage or commit until the user confirms.
+
+## Workflow
+
+1. **Gather context** — run these commands in parallel:
+   - `git status` — to see all tracked modifications and untracked files.
+   - `git diff` and `git diff --cached` — to see unstaged and staged changes.
+   - `git log --oneline -10` — to match the repository's commit message style.
+
+2. **Stage all relevant changes** — add all modified and untracked files that are part of the current work. Use specific file paths rather than `git add -A`. Do **not** stage files that likely contain secrets (`.env`, credentials, etc.) — warn the user if any are present.
+
+3. **Draft the commit message** — analyse the diff and write a concise commit message:
+   - One summary line (imperative mood, under 72 characters) describing the *why* / *what* of the change.
+   - If the change is non-trivial, add a blank line followed by bullet points elaborating key changes.
+   - **Don't pad small commits**: if the summary line already captures the change, omit the body entirely. Most single-purpose commits need only the summary line.
+   - **Stay high-level**: never reference code-level details like variable names, function names, method calls, or file paths in the commit message. Describe *what changed for the user or system*, not *which functions were modified*.
+   - Match the style and conventions visible in the recent git log.
+
+4. **Commit** — create the commit using a heredoc for the message:
+   ```bash
+   git commit -m "$(cat <<'EOF'
+   <summary line>
+
+   <optional body>
+   EOF
+   )"
+   ```
+
+5. **Verify** — run `git status` after the commit to confirm it succeeded and the working tree is clean (or shows only intentionally unstaged files).
+
+6. **Show the commit** — run `git log -1` and display the **entire** commit message (summary line and body) to the user so they can review it. Do not truncate or abbreviate — if the message has bullet points or a multi-line body, include all of it in your response.
+
+## Rules
+
+- Never amend an existing commit unless the user explicitly asks.
+- Never push to the remote unless the user explicitly asks.
+- Never use `--no-verify` or skip pre-commit hooks.
+- If a pre-commit hook fails, fix the issue, re-stage, and create a **new** commit (do not amend).
+- Never stage `.env`, credential files, or other secrets.
+- Never add `Co-Authored-By`, `Authored-By`, `Made-with` or any other attribution trailer to commit messages.

package/.claude/skills/prepare-release/SKILL.md

@@ -0,0 +1,97 @@
+---
+name: prepare-release
+description: Prepare a release by running lint + tests, bumping the package.json version, and appending a version summary to README.md. Use when the user asks to "prepare a release", "cut a release", or invokes /prepare-release. Stops immediately on lint/test failure so the user can fix issues before continuing.
+---
+
+# Prepare Release
+
+## When to use
+
+- User asks to prepare / cut a release.
+- User invokes `/prepare-release`.
+- Immediately before the release commit — this skill stages no files and creates no commit; hand off to `/git-commit` afterwards.
+
+## Release model
+
+The release content is the union of **(a)** commits since the last tag and **(b)** uncommitted user-facing changes in the working tree. Both are valid sources; the typical flow is that the fix being released sits uncommitted alongside the version bump and README update, and the user then commits them all together in a single release commit.
+
+Consequences:
+- Do **not** object to uncommitted changes in the working tree — they are expected and are part of what is being released. Treat them as release content, not as a blocker.
+- Do **not** require at least one committed change since the last tag. The release may consist entirely of working-tree changes that have not yet been committed.
+- When drafting the README bullets in step 5, summarise the user-facing changes visible across **both** sources (committed commits since the last tag **and** the diff of the working tree before this skill began modifying it).
+- The only changes this skill itself creates are in `package.json`, `package-lock.json`, and `README.md`. Everything else in the working tree was already the user's in-progress release content.
+
+## Arguments
+
+- `patch` (default) — bumps the patch component, e.g. `3.26.1` → `3.26.2`.
+- `minor` — bumps the minor component and resets patch, e.g. `3.26.1` → `3.27.0`.
+- `major` — bumps the major component and resets minor/patch, e.g. `3.26.1` → `4.0.0`.
+
+If the user supplies anything else, stop and ask for clarification.
+
+## Workflow
+
+Run steps in order. **If any step fails, stop immediately, report the failure, and do not proceed.** Do not modify `package.json`, `package-lock.json`, or `README.md` until lint and tests pass.
+
+### 1. Pre-flight checks (parallel)
+
+- `git status --short` — capture the working tree state. Per the release model above, treat uncommitted changes as part of the release content, not as a blocker. Still surface the list to the user so they can spot anything that looks unintended (e.g. a modified file they don't remember touching) before the eventual release commit.
+- `git rev-parse --abbrev-ref HEAD` — confirm the current branch. If it is not `master`, warn the user and ask whether to continue.
+- `git log --oneline $(git describe --tags --abbrev=0 2>/dev/null || git log --format=%H | tail -1)..HEAD` — collect commits since the last tag (or since the beginning if no tags exist). These feed the README summary in step 5 alongside the working-tree diff.
+- `git diff` and `git diff --cached` — capture the uncommitted user-facing changes. These also feed the README summary in step 5.
+- Read current version from `package.json`.
+
+Only stop at pre-flight if **both** the commit list and the uncommitted diff are empty — in that case there is genuinely nothing to release.
+
+### 2. Lint
+
+Run `npm run lint`. **Stop on non-zero exit.** Report the linter output verbatim and do not continue.
+
+### 3. Tests
+
+Run `npm test`. **Stop on non-zero exit.**
+
+Exception: the `Subagent` tests in `test/subagent.test.js` require a locally-running AgentX master (`snmpd`) and will fail with `ECONNREFUSED` if one is not present. If the only failures are Subagent `ECONNREFUSED` failures, report them and ask the user whether to proceed (they may have intentionally skipped running snmpd). All other failures are hard stops.
+
+### 4. Bump version
+
+Run `npm version <patch|minor|major> --no-git-tag-version`. This updates both `package.json` and `package-lock.json` atomically without creating a commit or tag. Capture the new version string for the README entry.
+
+If the argument was omitted, default to `patch`.
+
+### 5. Append README version summary
+
+- Read `README.md`.
+- Locate the `# License` heading near the end.
+- Insert a new version section **immediately before** `# License`, separated by a blank line above and below, in exactly this format:
+
+```
+# Version X.Y.Z - DD/MM/YYYY
+
+ * <concise user-facing summary of change 1>
+
+ * <concise user-facing summary of change 2>
+```
+
+Notes:
+- Date is **today's date** in `DD/MM/YYYY` (day/month/year) — use the date from the environment, not a hardcoded value.
+- Each bullet begins with a single space, then `*`, then a space. There is a blank line between bullets (match the style of the existing entries).
+- Bullets describe **user-visible changes** — not refactors, lint fixes, test additions, or internal tidy-ups. Write them like release notes, not commit subjects. Draw from **both** the commit list gathered in step 1 and the uncommitted working-tree diff; merge/reword where helpful so each line stands on its own.
+- If there is only one user-visible change, include just one bullet.
+- Do not touch any other part of `README.md`.
+
+### 6. Summary
+
+Report to the user, concisely:
+- New version number.
+- Bullets added to `README.md`.
+- The full list of uncommitted files now staged for the release commit — both the pre-existing working-tree changes and the three files this skill modified (`package.json`, `package-lock.json`, `README.md`). Flag anything that looks unexpected.
+
+Do **not** run `git add`, `git commit`, `git tag`, or `npm publish` — those are the user's decision. The next step is typically `/git-commit`.
+
+## Things to watch for
+
+- If `npm version` fails because the working tree is dirty, it has not been run with `--no-git-tag-version` correctly — re-check the command.
+- If the README insertion point (`# License`) cannot be found, stop and ask the user — do not guess.
+- If the lint or test commands are missing from `package.json`, stop and report.
+- Never bypass a failing check with `--no-verify`, `SKIP=`, or similar; the user must fix the underlying issue.

package/README.md

@@ -3719,6 +3719,10 @@ Example programs are included under the module's `example` directory.
 
  * Fix deleteTableRow string index handling
 
+# Version 3.26.2 - 21/04/2026
+
+ * Fix TypeError in oidInSubtree when varbind OID is null
+
 # License
 
 Copyright (c) 2020 Mark Abrahams <mark@abrahams.co.nz>

package/index.js

@@ -389,6 +389,9 @@ function oidFollowsOid (oidString, nextString) {
 }
 
 function oidInSubtree (oidString, nextString) {
+	if ( ! nextString ) {
+		return false;
+	}
 	var oid = oidString.split (".");
 	var next = nextString.split (".");
 
@@ -6886,6 +6889,9 @@ exports.ObjectParser = {
 	readUint32: readUint32,
 	readVarbindValue: readVarbindValue
 };
+exports.OidUtil = {
+	oidInSubtree: oidInSubtree
+};
 exports.ObjectTypeUtil = ObjectTypeUtil;
 exports.Authentication = Authentication;
 exports.Encryption = Encryption;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "net-snmp",
-  "version": "3.26.1",
+  "version": "3.26.2",
   "description": "JavaScript implementation of the Simple Network Management Protocol (SNMP)",
   "author": "Mark Abrahams <mark@abrahams.co.nz>",
   "license": "MIT",

package/test/oid-in-subtree.test.js

@@ -0,0 +1,36 @@
+const assert = require('assert');
+const snmp = require('..');
+
+const oidInSubtree = snmp.OidUtil.oidInSubtree;
+
+describe('oidInSubtree()', function () {
+
+	it('returns true when nextString is in the subtree', function () {
+		assert.strictEqual(oidInSubtree('1.3.6.1.2.1', '1.3.6.1.2.1.1.1.0'), true);
+	});
+
+	it('returns true when oidString equals nextString', function () {
+		assert.strictEqual(oidInSubtree('1.3.6.1.2.1', '1.3.6.1.2.1'), true);
+	});
+
+	it('returns false when nextString is outside the subtree', function () {
+		assert.strictEqual(oidInSubtree('1.3.6.1.2.1', '1.3.6.1.4.1.9'), false);
+	});
+
+	it('returns false when nextString is shorter than oidString', function () {
+		assert.strictEqual(oidInSubtree('1.3.6.1.2.1', '1.3.6.1'), false);
+	});
+
+	it('returns false when nextString is null (issue #298)', function () {
+		assert.strictEqual(oidInSubtree('1.3.6.1.2.1', null), false);
+	});
+
+	it('returns false when nextString is undefined', function () {
+		assert.strictEqual(oidInSubtree('1.3.6.1.2.1', undefined), false);
+	});
+
+	it('returns false when nextString is an empty string', function () {
+		assert.strictEqual(oidInSubtree('1.3.6.1.2.1', ''), false);
+	});
+
+});

package/test/subagent.test.js

@@ -5,38 +5,46 @@ const snmp = require('..');
 describe('Subagent', function() {
     let subagent;
     let mockSocket;
-    let mockServer;
+    let originalSocket;
+
+    function MockSocket() {
+        this.connect = () => {};
+        this.on = () => this;
+        this.write = () => {};
+        this.end = () => {};
+        this.destroy = () => {};
+    }
 
     beforeEach(function() {
-        // Create a mock server to simulate master agent
-        mockServer = net.createServer();
+        // Stub net.Socket so createSubagent does not open a real TCP connection
+        originalSocket = net.Socket;
+        net.Socket = MockSocket;
+
         mockSocket = {
             connect: () => {},
             on: () => {},
             write: () => {},
             end: () => {}
         };
-        
-        // Use the factory method instead of constructor
+
         subagent = snmp.createSubagent({
             master: 'localhost',
             masterPort: 705,
             timeout: 5,
             description: 'Test Subagent'
         });
-        
-        // Mock socket connection to avoid actual networking
+
         subagent.socket = mockSocket;
         subagent.sessionID = 123;
     });
 
     afterEach(function() {
-        if (mockServer) {
-            mockServer.close();
-        }
         if (subagent && typeof subagent.close === 'function') {
             subagent.close();
         }
+        if (originalSocket) {
+            net.Socket = originalSocket;
+        }
     });
 
     describe('Constructor', function() {