@chemx/starter-kit 26.9.26-253 → 26.9.28-1234

package/cli/path-scope.js

@@ -0,0 +1,113 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+/**
+ * Resolves a target path against a base directory and ensures it does not escape the boundary.
+ *
+ * @param {string} targetPath File or directory path to validate.
+ * @param {string} [baseDir=process.cwd()] Allowed root boundary directory.
+ * @returns {string} Fully resolved, validated path within baseDir.
+ * @throws {Error} If path contains null bytes, attempts traversal, or escapes baseDir.
+ */
+export const resolveSafePath = (targetPath, baseDir = process.cwd()) => {
+  if (!targetPath || typeof targetPath !== 'string') {
+    throw new Error('A valid file path string is required.');
+  }
+
+  if (targetPath.includes('\0')) {
+    throw new Error('Null byte detected in path.');
+  }
+
+  const realBase = fs.existsSync(baseDir) ? fs.realpathSync(baseDir) : path.resolve(baseDir);
+  const resolvedTarget = path.isAbsolute(targetPath)
+    ? path.resolve(targetPath)
+    : path.resolve(realBase, targetPath);
+
+  const relLexical = path.relative(realBase, resolvedTarget);
+  const isLexicalEscape = relLexical.startsWith('..') || path.isAbsolute(relLexical);
+
+  if (isLexicalEscape) {
+    throw new Error(`Path traversal rejected: "${targetPath}" is outside allowed workspace root "${realBase}".`);
+  }
+
+  if (fs.existsSync(resolvedTarget)) {
+    const realTarget = fs.realpathSync(resolvedTarget);
+    const relReal = path.relative(realBase, realTarget);
+    const isSymlinkEscape = relReal.startsWith('..') || path.isAbsolute(relReal);
+    if (isSymlinkEscape) {
+      throw new Error(`Path traversal rejected: "${targetPath}" resolves outside allowed workspace root via symlink.`);
+    }
+    return realTarget;
+  }
+
+  return resolvedTarget;
+};
+
+/**
+ * Checks whether a target path attempts traversal or escapes the boundary.
+ *
+ * @param {string} targetPath Path to inspect.
+ * @param {string} [baseDir=process.cwd()] Boundary directory.
+ * @returns {boolean} True if the path escapes baseDir or is invalid, false otherwise.
+ */
+export const isPathTraversal = (targetPath, baseDir = process.cwd()) => {
+  try {
+    const resolved = resolveSafePath(targetPath, baseDir);
+    const realBase = fs.existsSync(baseDir) ? fs.realpathSync(baseDir) : path.resolve(baseDir);
+    const rel = path.relative(realBase, resolved);
+    if (rel === '') return true;
+    return false;
+  } catch {
+    return true;
+  }
+};
+
+const hasDotNetProject = (cwd) => {
+  try {
+    const rootEntries = fs.readdirSync(cwd, { withFileTypes: true });
+    const hasSln = rootEntries.some((e) => e.isFile() && e.name.endsWith('.sln'));
+    const hasRootCsproj = rootEntries.some((e) => e.isFile() && e.name.endsWith('.csproj'));
+    if (hasSln || hasRootCsproj) return true;
+
+    return rootEntries.some((e) => {
+      const isCandidateDir = e.isDirectory() && e.name !== 'src' && e.name !== 'node_modules' && !e.name.startsWith('.');
+      if (!isCandidateDir) return false;
+      const subPath = path.join(cwd, e.name);
+      try {
+        return fs.readdirSync(subPath).some((f) => f.endsWith('.csproj'));
+      } catch (err) {
+        if (process.env.DEBUG) process.stderr.write(`[debug] Read failed: ${err?.message}\n`);
+        return false;
+      }
+    });
+  } catch (err) {
+    if (process.env.DEBUG) process.stderr.write(`[debug] Scan failed: ${err?.message}\n`);
+    return false;
+  }
+};
+
+export const resolveTargetDir = (customOrFlag = null, dirFlag = null, cwd = process.cwd()) => {
+  const isCustomPath = Boolean(customOrFlag && !customOrFlag.startsWith('--dir='));
+  if (isCustomPath) {
+    return customOrFlag;
+  }
+
+  const effectiveFlag = dirFlag || (customOrFlag?.startsWith('--dir=') ? customOrFlag : null);
+  if (effectiveFlag) {
+    const [, flagValue] = effectiveFlag.split('=');
+    if (flagValue !== undefined) {
+      return flagValue;
+    }
+  }
+
+  if (hasDotNetProject(cwd)) {
+    return '.';
+  }
+
+  const hasSrcDirectory = fs.existsSync(path.resolve(cwd, 'src'));
+  if (hasSrcDirectory) {
+    return 'src';
+  }
+
+  return '.';
+};

package/cli/path-traversal.spec.js

@@ -0,0 +1,242 @@
+import test from 'node:test';
+import assert from 'node:assert';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { DatabaseSync } from 'node:sqlite';
+
+import { resolveSafePath, isPathTraversal } from './path-scope.js';
+import { readTokenOptimized } from './reader.js';
+import { handleChemxRead } from './mcp/tools-read.js';
+import { patchFile, writeFile } from './patcher.js';
+import { handleChemxPatch } from './mcp/tools-patch.js';
+import { handleChemxWrite } from './mcp/tools-write.js';
+import { requestFileLock, releaseFileLock, getFileLockStatus } from './team/team-db-locks.js';
+import { handleChemxTeamLock } from './mcp/tools-team-locks.js';
+import { handleLockCommand, handleUnlockCommand } from './team/team-commands-lock.js';
+import { initTeamSchema } from './team/team-schema.js';
+
+test('path-scope: resolveSafePath allows legitimate workspace paths', () => {
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'chemx-scope-test-'));
+  const testFile = path.join(tmpDir, 'src', 'index.js');
+  fs.mkdirSync(path.dirname(testFile), { recursive: true });
+  fs.writeFileSync(testFile, 'export const x = 1;', 'utf-8');
+
+  try {
+    const relResolved = resolveSafePath('src/index.js', tmpDir);
+    assert.strictEqual(relResolved, testFile);
+
+    const absResolved = resolveSafePath(testFile, tmpDir);
+    assert.strictEqual(absResolved, testFile);
+
+    assert.strictEqual(isPathTraversal('src/index.js', tmpDir), false);
+    assert.strictEqual(isPathTraversal(testFile, tmpDir), false);
+  } finally {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  }
+});
+
+test('path-scope: resolveSafePath and isPathTraversal reject traversal attacks', () => {
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'chemx-scope-attack-'));
+
+  try {
+    assert.throws(
+      () => resolveSafePath('../../../etc/passwd', tmpDir),
+      /Path traversal rejected/
+    );
+    assert.throws(
+      () => resolveSafePath('/etc/passwd', tmpDir),
+      /Path traversal rejected/
+    );
+    assert.throws(
+      () => resolveSafePath('foo\0bar.js', tmpDir),
+      /Null byte detected/
+    );
+
+    assert.strictEqual(isPathTraversal('../../../etc/passwd', tmpDir), true);
+    assert.strictEqual(isPathTraversal('/etc/passwd', tmpDir), true);
+    assert.strictEqual(isPathTraversal('.', tmpDir), true);
+  } finally {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  }
+});
+
+test('path-scope: rejects symlink escapes targeting outside workspace', () => {
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'chemx-symlink-root-'));
+  const outsideDir = fs.mkdtempSync(path.join(os.tmpdir(), 'chemx-symlink-outside-'));
+  const outsideFile = path.join(outsideDir, 'secret.txt');
+  fs.writeFileSync(outsideFile, 'secret-data', 'utf-8');
+
+  const symlinkPath = path.join(tmpDir, 'symlink-secret.txt');
+  try {
+    fs.symlinkSync(outsideFile, symlinkPath);
+    assert.throws(
+      () => resolveSafePath('symlink-secret.txt', tmpDir),
+      /Path traversal rejected/
+    );
+    assert.strictEqual(isPathTraversal('symlink-secret.txt', tmpDir), true);
+  } finally {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+    fs.rmSync(outsideDir, { recursive: true, force: true });
+  }
+});
+
+test('reader: readTokenOptimized and handleChemxRead block path traversal', () => {
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'chemx-reader-sec-'));
+  const legitimateFile = path.join(tmpDir, 'legit.ts');
+  fs.writeFileSync(legitimateFile, 'export const safe = true;\n', 'utf-8');
+
+  try {
+    const safeRes = readTokenOptimized('legit.ts', { cwd: tmpDir });
+    assert.ok(safeRes.content.includes('export const safe = true;'));
+
+    assert.throws(
+      () => readTokenOptimized('../../../etc/passwd', { cwd: tmpDir }),
+      /Path traversal rejected/
+    );
+    assert.throws(
+      () => readTokenOptimized('/etc/passwd', { cwd: tmpDir }),
+      /Path traversal rejected/
+    );
+
+    assert.throws(
+      () => handleChemxRead({ path: '../../../etc/passwd', cwd: tmpDir }, tmpDir),
+      /Path traversal rejected/
+    );
+    assert.throws(
+      () => handleChemxRead({ path: '/etc/passwd', cwd: tmpDir }, tmpDir),
+      /Path traversal rejected/
+    );
+  } finally {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  }
+});
+
+test('patcher: patchFile, writeFile, and MCP tools block path traversal', () => {
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'chemx-patcher-sec-'));
+  const legitimateFile = path.join(tmpDir, 'legit.ts');
+  fs.writeFileSync(legitimateFile, 'export const val = 1;\n', 'utf-8');
+
+  try {
+    const patchRes = patchFile('legit.ts', {
+      targetContent: 'val = 1;',
+      replacementContent: 'val = 2;',
+      cwd: tmpDir,
+      skipIndex: true
+    });
+    assert.strictEqual(patchRes.status, 'ok');
+
+    assert.throws(
+      () => patchFile('../../../etc/passwd', {
+        targetContent: 'root',
+        replacementContent: 'hacked',
+        cwd: tmpDir,
+        skipIndex: true
+      }),
+      /Path traversal rejected/
+    );
+    assert.throws(
+      () => patchFile('/etc/passwd', {
+        targetContent: 'root',
+        replacementContent: 'hacked',
+        cwd: tmpDir,
+        skipIndex: true
+      }),
+      /Path traversal rejected/
+    );
+
+    assert.throws(
+      () => writeFile('../../../etc/evil.txt', {
+        content: 'exploit',
+        cwd: tmpDir,
+        skipIndex: true
+      }),
+      /Path traversal rejected/
+    );
+    assert.throws(
+      () => writeFile('/tmp/evil-outside.txt', {
+        content: 'exploit',
+        cwd: tmpDir,
+        skipIndex: true
+      }),
+      /Path traversal rejected/
+    );
+
+    assert.throws(
+      () => handleChemxPatch({
+        path: '../../../etc/passwd',
+        targetContent: 'a',
+        replacementContent: 'b'
+      }, tmpDir),
+      /Path traversal rejected/
+    );
+
+    assert.throws(
+      () => handleChemxWrite({
+        path: '../../../etc/passwd',
+        content: 'malicious'
+      }, tmpDir),
+      /Path traversal rejected/
+    );
+  } finally {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  }
+});
+
+test('team lock: requestFileLock, releaseFileLock, and getFileLockStatus block path traversal', () => {
+  const db = new DatabaseSync(':memory:');
+  db.exec('PRAGMA foreign_keys = ON;');
+  initTeamSchema(db);
+
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'chemx-team-sec-'));
+
+  try {
+    const safeLock = requestFileLock(db, 'src/button.vue', '@agent-1', { cwd: tmpDir });
+    assert.strictEqual(safeLock.granted, true);
+    assert.strictEqual(safeLock.lease.file_path, 'src/button.vue');
+
+    const safeStatus = getFileLockStatus(db, 'src/button.vue', { cwd: tmpDir });
+    assert.strictEqual(safeStatus.lease.locked_by, '@agent-1');
+
+    const safeUnlock = releaseFileLock(db, 'src/button.vue', '@agent-1', { cwd: tmpDir });
+    assert.strictEqual(safeUnlock.success, true);
+
+    const badLock1 = requestFileLock(db, '../../../etc/passwd', '@attacker', { cwd: tmpDir });
+    assert.strictEqual(badLock1.granted, false);
+    assert.strictEqual(badLock1.reason, 'path_traversal');
+
+    const badLock2 = requestFileLock(db, '/etc/passwd', '@attacker', { cwd: tmpDir });
+    assert.strictEqual(badLock2.granted, false);
+    assert.strictEqual(badLock2.reason, 'path_traversal');
+
+    const badUnlock = releaseFileLock(db, '../../../etc/passwd', '@attacker', { cwd: tmpDir });
+    assert.strictEqual(badUnlock.success, false);
+    assert.strictEqual(badUnlock.reason, 'path_traversal');
+
+    const badStatus = getFileLockStatus(db, '../../../etc/passwd', { cwd: tmpDir });
+    assert.strictEqual(badStatus.error, 'path_traversal');
+
+    const cliLockRes = handleLockCommand(db, ['acquire', '../../../etc/passwd'], {}, false, tmpDir);
+    assert.strictEqual(cliLockRes.error, 'path_traversal');
+
+    const cliUnlockRes = handleUnlockCommand(db, ['../../../etc/passwd'], {}, false, tmpDir);
+    assert.strictEqual(cliUnlockRes.error, 'path_traversal');
+  } finally {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  }
+});
+
+test('team lock: handleChemxTeamLock MCP handler rejects path traversal', async () => {
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'chemx-mcp-lock-sec-'));
+  try {
+    const res = await handleChemxTeamLock({
+      action: 'acquire',
+      filePath: '../../../etc/passwd',
+      agentId: '@attacker'
+    }, tmpDir);
+
+    assert.strictEqual(res.error, 'path_traversal');
+  } finally {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  }
+});

package/cli/reader.js

@@ -3,6 +3,7 @@ import path from 'node:path';
 import { parse } from '@babel/parser';
 import traverseModule from '@babel/traverse';
 import { ANSI } from './theme.js';
+import { resolveSafePath } from './path-scope.js';
 
 import {
   stripCodeComments,
@@ -214,7 +215,8 @@ export const readTokenOptimized = (targetPath, options = {}) => {
     if (endLine === undefined && colonMatch[3]) endLine = parseInt(colonMatch[3], 10);
   }
 
-  const resolvedPath = path.resolve(process.cwd(), rawPath);
+  const cwd = options.cwd || process.cwd();
+  const resolvedPath = resolveSafePath(rawPath, cwd);
 
   if (!fs.existsSync(resolvedPath)) {
     throw new Error(`File not found: ${rawPath}`);

package/cli/search.d.ts

@@ -101,7 +101,8 @@ export declare function runSearch(
 
 export declare function resolveTargetDir(
   customOrFlag?: string | null,
-  dirFlag?: string | null
+  dirFlag?: string | null,
+  cwd?: string
 ): string;
 
 export declare function findSymbolDefinition(

package/cli/search.js

@@ -207,27 +207,7 @@ const formatTierBadge = (tier) => {
   return map[tier] || `${ANSI.DIM}[${tier}]${ANSI.RESET}`;
 };
 
-export const resolveTargetDir = (customOrFlag = null, dirFlag = null) => {
-  const isCustomPath = Boolean(customOrFlag && !customOrFlag.startsWith('--dir='));
-  if (isCustomPath) {
-    return customOrFlag;
-  }
-
-  const effectiveFlag = dirFlag || (customOrFlag?.startsWith('--dir=') ? customOrFlag : null);
-  if (effectiveFlag) {
-    const [, flagValue] = effectiveFlag.split('=');
-    if (flagValue !== undefined) {
-      return flagValue;
-    }
-  }
-
-  const hasSrcDirectory = fs.existsSync('src');
-  if (hasSrcDirectory) {
-    return 'src';
-  }
-
-  return '.';
-};
+export { resolveTargetDir } from './path-scope.js';
 
 export const printSearchHelp = () => {
   const BOLD = '\x1b[1m';

package/cli/search.spec.js

@@ -57,6 +57,18 @@ test('resolveTargetDir: defaults to src if present, otherwise . when no flags pr
   assert.strictEqual(resultNoArgs, expectedDefault);
 });
 
+test('resolveTargetDir: defaults to . when .sln or csproj exists at repo root', () => {
+  const tmpDir = path.resolve('scratch/test-dotnet-repo');
+  fs.mkdirSync(tmpDir, { recursive: true });
+  fs.mkdirSync(path.join(tmpDir, 'src'), { recursive: true });
+  fs.writeFileSync(path.join(tmpDir, 'Solution.sln'), '', 'utf8');
+
+  const resolved = resolveTargetDir(null, null, tmpDir);
+  assert.strictEqual(resolved, '.');
+
+  fs.rmSync(tmpDir, { recursive: true, force: true });
+});
+
 test('search-db: indexes symbols with line ranges and finds definition', () => {
   const db = openIndexDb();
   if (!db) return;

package/cli/team/team-commands-lock.js

@@ -1,7 +1,8 @@
 import { requestFileLock, releaseFileLock } from './team-db.js';
 import { formatLockHelpCard } from './team-format.js';
+import { isPathTraversal } from '../path-scope.js';
 
-export const handleLockCommand = (db, nonFlagPositional, flags, isCli) => {
+export const handleLockCommand = (db, nonFlagPositional, flags, isCli, cwd = process.cwd()) => {
   const isLockHelp = flags.help || nonFlagPositional.includes('--help') || nonFlagPositional.includes('-h') || nonFlagPositional.includes('help');
   if (isLockHelp) {
     if (isCli) process.stdout.write(formatLockHelpCard());
@@ -24,13 +25,19 @@ export const handleLockCommand = (db, nonFlagPositional, flags, isCli) => {
   }
 
   if (action === 'release') {
-    return handleUnlockCommand(db, [file], flags, isCli);
+    return handleUnlockCommand(db, [file], flags, isCli, cwd);
+  }
+
+  if (isPathTraversal(file, cwd)) {
+    if (isCli) process.stderr.write('\x1b[31m✕ Path traversal rejected: file path must be within workspace\x1b[0m\n');
+    return { error: 'path_traversal' };
   }
 
   const res = requestFileLock(db, file, flags.as || '@agent', {
     purpose: flags.purpose,
     priority: flags.priority,
-    pid: flags.pid ? Number(flags.pid) : 0
+    pid: flags.pid ? Number(flags.pid) : 0,
+    cwd
   });
 
   if (isCli) {
@@ -41,7 +48,7 @@ export const handleLockCommand = (db, nonFlagPositional, flags, isCli) => {
   return res;
 };
 
-export const handleUnlockCommand = (db, nonFlagPositional, flags, isCli) => {
+export const handleUnlockCommand = (db, nonFlagPositional, flags, isCli, cwd = process.cwd()) => {
   const isUnlockHelp = flags.help || nonFlagPositional.includes('--help') || nonFlagPositional.includes('-h') || nonFlagPositional.includes('help');
   if (isUnlockHelp) {
     if (isCli) process.stdout.write(formatLockHelpCard());
@@ -54,7 +61,12 @@ export const handleUnlockCommand = (db, nonFlagPositional, flags, isCli) => {
     return { error: 'filePath required' };
   }
 
-  const res = releaseFileLock(db, file, flags.as || '@agent');
+  if (isPathTraversal(file, cwd)) {
+    if (isCli) process.stderr.write('\x1b[31m✕ Path traversal rejected: file path must be within workspace\x1b[0m\n');
+    return { error: 'path_traversal' };
+  }
+
+  const res = releaseFileLock(db, file, flags.as || '@agent', { cwd });
   if (isCli) {
     if (flags.isJson) process.stdout.write(`${JSON.stringify(res, null, 2)}\n`);
     else if (res.success) process.stdout.write(`\x1b[32m✔\x1b[0m Released lock on ${file}\n`);

package/cli/team/team-commands.js

@@ -396,11 +396,11 @@ export const runTeamCli = (rawArgs = [], isCli = false, cwd = process.cwd()) =>
   }
 
   if (subCommand === 'lock') {
-    return handleLockCommand(db, nonFlagPositional, flags, isCli);
+    return handleLockCommand(db, nonFlagPositional, flags, isCli, cwd);
   }
 
   if (subCommand === 'unlock') {
-    return handleUnlockCommand(db, nonFlagPositional, flags, isCli);
+    return handleUnlockCommand(db, nonFlagPositional, flags, isCli, cwd);
   }
 
   if (subCommand === 'triage') {

package/cli/team/team-db-locks.js

@@ -3,12 +3,29 @@
  * Prevents race collisions with deterministic queueing and reactive promotion
  */
 
+import path from 'node:path';
+import { isPathTraversal, resolveSafePath } from '../path-scope.js';
 import { postFeedEvent } from './team-db-feed.js';
 import { DEFAULT_TTL_MS, cleanExpiredLeases, promoteNextWaiter, enqueueWaiter } from './team-db-lock-promotion.js';
 import { withImmediateTransaction } from './team-db-transaction.js';
 
 export { cleanExpiredLeases, promoteNextWaiter } from './team-db-lock-promotion.js';
 
+const resolveBaseDir = (db, options = {}) => {
+  if (options.cwd) return options.cwd;
+  try {
+    if (typeof db?.location === 'function') {
+      const loc = db.location();
+      if (loc && loc !== ':memory:' && loc.includes('.chemx')) {
+        return path.dirname(path.dirname(path.resolve(loc)));
+      }
+    }
+  } catch {
+    // fallback
+  }
+  return process.cwd();
+};
+
 const normalizeAgentId = (id) => {
   const hasId = Boolean(id);
   if (!hasId) return null;
@@ -23,13 +40,19 @@ export const requestFileLock = (db, filePath, agentId, options = {}) => {
   const canRequest = hasDb && hasPath && hasAgent;
   if (!canRequest) return { granted: false, reason: 'missing_args' };
 
+  const baseDir = resolveBaseDir(db, options);
+  if (isPathTraversal(filePath, baseDir)) {
+    return { granted: false, reason: 'path_traversal' };
+  }
+  const cleanPath = path.relative(baseDir, resolveSafePath(filePath, baseDir));
+
   const cleanId = normalizeAgentId(agentId);
   const pid = typeof options.pid === 'number' ? options.pid : 0;
 
   return withImmediateTransaction(db, () => {
     cleanExpiredLeases(db);
 
-    const existingLease = db.prepare('SELECT * FROM file_leases WHERE file_path = ?').get(filePath);
+    const existingLease = db.prepare('SELECT * FROM file_leases WHERE file_path = ?').get(cleanPath);
     const now = Date.now();
     const ttlMs = options.ttlMs || DEFAULT_TTL_MS;
     const expiresAt = now + ttlMs;
@@ -43,63 +66,75 @@ export const requestFileLock = (db, filePath, agentId, options = {}) => {
           expires_at = excluded.expires_at,
           purpose = excluded.purpose,
           pid = excluded.pid`;
-      db.prepare(upsertSql).run(filePath, cleanId, now, expiresAt, purpose, pid);
+      db.prepare(upsertSql).run(cleanPath, cleanId, now, expiresAt, purpose, pid);
 
       postFeedEvent(db, {
         author_id: cleanId,
         event_type: 'lock_acquired',
-        file_path: filePath,
-        message: `${cleanId} acquired lock on ${filePath}`
+        file_path: cleanPath,
+        message: `${cleanId} acquired lock on ${cleanPath}`
       });
 
-      return { granted: true, lease: { file_path: filePath, locked_by: cleanId, expires_at: expiresAt, pid } };
+      return { granted: true, lease: { file_path: cleanPath, locked_by: cleanId, expires_at: expiresAt, pid } };
     }
 
-    return enqueueWaiter(db, filePath, cleanId, existingLease, options, now);
+    return enqueueWaiter(db, cleanPath, cleanId, existingLease, options, now);
   });
 };
 
-export const releaseFileLock = (db, filePath, agentId) => {
+export const releaseFileLock = (db, filePath, agentId, options = {}) => {
   const hasDb = Boolean(db);
   const hasPath = Boolean(filePath);
   const hasAgent = Boolean(agentId);
   const canRelease = hasDb && hasPath && hasAgent;
   if (!canRelease) return { success: false, reason: 'missing_args' };
 
+  const baseDir = resolveBaseDir(db, options);
+  if (isPathTraversal(filePath, baseDir)) {
+    return { success: false, reason: 'path_traversal' };
+  }
+  const cleanPath = path.relative(baseDir, resolveSafePath(filePath, baseDir));
+
   const cleanId = normalizeAgentId(agentId);
 
   return withImmediateTransaction(db, () => {
     cleanExpiredLeases(db);
 
-    const existingLease = db.prepare('SELECT * FROM file_leases WHERE file_path = ?').get(filePath);
+    const existingLease = db.prepare('SELECT * FROM file_leases WHERE file_path = ?').get(cleanPath);
     const isHolder = Boolean(existingLease) && existingLease.locked_by === cleanId;
     if (!isHolder) {
       return { success: false, reason: 'not_holder' };
     }
 
-    db.prepare('DELETE FROM file_leases WHERE file_path = ?').run(filePath);
+    db.prepare('DELETE FROM file_leases WHERE file_path = ?').run(cleanPath);
     postFeedEvent(db, {
       author_id: cleanId,
       event_type: 'lock_released',
-      file_path: filePath,
-      message: `${cleanId} released lock on ${filePath}`
+      file_path: cleanPath,
+      message: `${cleanId} released lock on ${cleanPath}`
     });
 
-    const next = promoteNextWaiter(db, filePath);
+    const next = promoteNextWaiter(db, cleanPath);
     const promotedWaiter = next ? next.waiter.agent_id : null;
     return { success: true, promotedWaiter };
   });
 };
 
-export const getFileLockStatus = (db, filePath) => {
+export const getFileLockStatus = (db, filePath, options = {}) => {
   const hasDb = Boolean(db);
   const hasPath = Boolean(filePath);
   const canGet = hasDb && hasPath;
   if (!canGet) return null;
 
+  const baseDir = resolveBaseDir(db, options);
+  if (isPathTraversal(filePath, baseDir)) {
+    return { lease: null, waiters: [], error: 'path_traversal' };
+  }
+  const cleanPath = path.relative(baseDir, resolveSafePath(filePath, baseDir));
+
   cleanExpiredLeases(db);
-  const lease = db.prepare('SELECT * FROM file_leases WHERE file_path = ?').get(filePath);
+  const lease = db.prepare('SELECT * FROM file_leases WHERE file_path = ?').get(cleanPath);
   const query = "SELECT * FROM file_lock_queue WHERE file_path = ? AND status = 'waiting' ORDER BY priority ASC, id ASC";
-  const waiters = db.prepare(query).all(filePath);
+  const waiters = db.prepare(query).all(cleanPath);
   return { lease: lease || null, waiters };
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chemx/starter-kit",
-  "version": "26.9.26-253",
+  "version": "26.9.28-1234",
   "description": "Chemical X Protocol: Private drop-in architecture starter kit and capsule generator",
   "type": "module",
   "bin": {