outask 0.0.0-stage → 1.7.0

package/src/project-lock.mjs

@@ -0,0 +1,74 @@
+import { createHash } from 'node:crypto';
+import { chmodSync, lstatSync, mkdirSync, realpathSync, writeFileSync } from 'node:fs';
+import { userInfo } from 'node:os';
+import paths, { join } from 'node:path';
+import { fail } from './errors.mjs';
+import { databaseSync } from './sqlite.mjs';
+
+export function lockInsideProject(root, directory, path = paths) {
+  const location = path.relative(root, directory);
+  return location === '' || (!path.isAbsolute(location) && location !== '..' && !location.startsWith(`..${path.sep}`));
+}
+
+export function projectLockPath(root) {
+  const windows = process.platform === 'win32';
+  const canonical = realpathSync(root);
+  // A fixed host path keeps CLI, MCP and HTTP environments in one lock namespace.
+  const directory = windows
+    ? join(userInfo().homedir, 'AppData', 'Local', 'Programs', 'Outask', 'locks')
+    : join(realpathSync('/var/tmp'), `task-tracker-locks-${process.getuid()}`);
+  if (lockInsideProject(canonical, directory)) {
+    fail('WRITE_ERROR', 'project lock directory must be outside the project');
+  }
+  mkdirSync(directory, { recursive: true, mode: 0o700 });
+  const info = lstatSync(directory);
+  if (!info.isDirectory() || (!windows && (info.uid !== process.getuid() || (info.mode & 0o077)))) {
+    fail('WRITE_ERROR', `${directory}: expected a private directory owned by the current user`);
+  }
+  return join(directory, `${createHash('sha256').update(windows ? canonical.toLowerCase() : canonical).digest('hex')}.sqlite`);
+}
+
+function checkLegacy(project, action) {
+  const path = join(project.directory, '.task-tracker.json.lock');
+  try { lstatSync(path); } catch (error) {
+    if (error.code === 'ENOENT') return;
+    fail('WRITE_ERROR', `${path}: cannot inspect legacy lock (${error.code})`);
+  }
+  fail('PROJECT_BUSY', `${path}: cannot lock ${action} (EEXIST); stop all older writers before manually removing this legacy lock; do not mix writer versions`);
+}
+
+export function withProjectLock(project, action, operation, wait = 0) {
+  checkLegacy(project, action);
+  let database;
+  let path;
+  try {
+    path = projectLockPath(project.root);
+    // Do not open/close an existing file outside SQLite: POSIX closes can drop
+    // locks held by another SQLite connection in this process.
+    try { writeFileSync(path, '', { flag: 'wx', mode: 0o600 }); } catch (error) {
+      if (error.code !== 'EEXIST') throw error;
+    }
+    const info = lstatSync(path);
+    if (!info.isFile() || (process.platform !== 'win32' && info.uid !== process.getuid())) {
+      fail('WRITE_ERROR', `${path}: expected a regular file owned by the current user`);
+    }
+    if (process.platform !== 'win32') chmodSync(path, 0o600);
+    const DatabaseSync = databaseSync();
+    database = new DatabaseSync(path);
+    database.exec(`PRAGMA busy_timeout = ${Math.max(0, Math.trunc(wait))}`);
+    database.exec('BEGIN EXCLUSIVE');
+  } catch (error) {
+    database?.close();
+    if (error.code === 'WRITE_ERROR') throw error;
+    fail(error.errcode === 5 || error.errcode === 6 ? 'PROJECT_BUSY' : 'WRITE_ERROR',
+      `${path ?? project.root}: cannot lock ${action} (${error.code ?? error.message}); retry after the current operation finishes`);
+  }
+  try {
+    checkLegacy(project, action);
+    return operation();
+  } finally {
+    // Closing rolls back the empty transaction; the OS also releases it on death.
+    // Never unlink: another process may already have opened the same inode.
+    database.close();
+  }
+}

package/src/projects.mjs

@@ -0,0 +1,33 @@
+import { existsSync, realpathSync, statSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { readConfig } from './config.mjs';
+import { fail } from './errors.mjs';
+
+function directory(path) {
+  try {
+    if (!statSync(path).isDirectory()) fail('PROJECT_NOT_FOUND', `${path}: expected a project directory`);
+    return realpathSync(path);
+  } catch (error) {
+    if (error.code === 'PROJECT_NOT_FOUND') throw error;
+    fail('PROJECT_NOT_FOUND', `${path}: cannot access project directory (${error.code})`);
+  }
+}
+
+export function selectProject({ name, path, config }, env = process.env) {
+  if (name === undefined) return directory(resolve(path ?? process.cwd()));
+  if (!name || name === '.' || name === '..' || /[\\/\0]/.test(name)) {
+    fail('INVALID_INPUT', '--project expects one configured name; use --project-path for a directory');
+  }
+  const { path: configPath, settings } = readConfig(config, env);
+  if (!existsSync(configPath)) fail('PROJECT_NOT_FOUND', `project ${name} is unknown; no config at ${configPath}`);
+  const candidates = [];
+  if (settings.projects_root !== undefined) {
+    const child = join(settings.projects_root, name);
+    if (existsSync(child)) candidates.push(directory(child));
+  }
+  if (Object.hasOwn(settings.projects ?? {}, name)) candidates.push(directory(settings.projects[name]));
+  const matches = [...new Set(candidates)];
+  if (!matches.length) fail('PROJECT_NOT_FOUND', `unknown project ${name}; use --project-path or configure its location`);
+  if (matches.length > 1) fail('AMBIGUOUS_PROJECT', `project ${name} identifies multiple directories; use --project-path`);
+  return matches[0];
+}

package/src/response.mjs

@@ -0,0 +1,75 @@
+import { responseBytes } from './limits.mjs';
+
+function stringBytes(value, ceiling) {
+  let bytes = 2;
+  for (let index = 0; index < value.length && bytes <= ceiling; index++) {
+    const code = value.charCodeAt(index);
+    if (code === 34 || code === 92 || [8, 9, 10, 12, 13].includes(code)) bytes += 2;
+    else if (code < 32) bytes += 6;
+    else if (code < 128) bytes++;
+    else if (code < 2048) bytes += 2;
+    else if (code >= 0xd800 && code <= 0xdbff && value.charCodeAt(index + 1) >= 0xdc00
+      && value.charCodeAt(index + 1) <= 0xdfff) {
+      bytes += 4;
+      index++;
+    } else bytes += code >= 0xd800 && code <= 0xdfff ? 6 : 3;
+  }
+  return bytes;
+}
+
+// Count escaped UTF-8 and indentation before JSON.stringify can allocate output.
+// An explicit stack also bounds deeply nested input without recursive traversal.
+export function jsonBytes(value, indent = 2, ceiling = responseBytes) {
+  const pending = [{ value, depth: 0 }];
+  let bytes = 0;
+  while (pending.length && bytes <= ceiling) {
+    const { value: current, depth } = pending.pop();
+    if (typeof current === 'string') bytes += stringBytes(current, ceiling - bytes);
+    else if (current === null || typeof current !== 'object') {
+      bytes += current === null || (typeof current === 'number' && !Number.isFinite(current)) ? 4 : String(current).length;
+    } else {
+      const array = Array.isArray(current);
+      const keys = array ? undefined : Object.keys(current);
+      const length = array ? current.length : keys.length;
+      bytes += length === 0 ? 2 : indent
+        ? 2 + 2 * length + length * indent * (depth + 1) + indent * depth
+        : length + 1;
+      if (!array) {
+        for (const key of keys) {
+          bytes += stringBytes(key, ceiling - bytes) + (indent ? 2 : 1);
+          if (bytes > ceiling) break;
+        }
+      }
+      if (bytes > ceiling) break;
+      for (let index = length - 1; index >= 0; index--) {
+        pending.push({ value: current[array ? index : keys[index]], depth: depth + 1 });
+      }
+    }
+  }
+  return bytes;
+}
+
+export function jsonText(value, indent = 2, ceiling = responseBytes) {
+  if (jsonBytes(value, indent, ceiling) > ceiling) return undefined;
+  return JSON.stringify(value, null, indent);
+}
+
+export function textBuffer(ceiling = responseBytes) {
+  const parts = [];
+  let bytes = 0;
+  return {
+    add(text) {
+      bytes += Buffer.byteLength(text, 'utf8');
+      if (bytes > ceiling) return false;
+      parts.push(text);
+      return true;
+    },
+    spaces(count) {
+      bytes += count;
+      if (bytes > ceiling) return false;
+      parts.push(' '.repeat(count));
+      return true;
+    },
+    finish() { return bytes <= ceiling ? parts.join('') : undefined; },
+  };
+}

package/src/schema.mjs

@@ -0,0 +1,76 @@
+import { statSync } from 'node:fs';
+import { fail } from './errors.mjs';
+import { jsonText } from './response.mjs';
+import { responseBytes } from './limits.mjs';
+import { readBudget, readText } from './input.mjs';
+import { replaceFile, withProjectLock } from './service.mjs';
+import { defaultSearch, openProject, retainedFiles, standardStores } from './stores.mjs';
+import { scanProject } from './validation.mjs';
+
+function checkOptions(options, writing = false) {
+  if (!options || typeof options !== 'object' || Array.isArray(options)
+    || Object.keys(options).some((key) => !['schemaPath', ...(writing ? ['replace'] : [])].includes(key))
+    || (writing && options.replace !== undefined && typeof options.replace !== 'boolean')) {
+    fail('INVALID_INPUT', `options must contain only schemaPath${writing ? ' and boolean replace' : ''}`);
+  }
+}
+
+function effectiveSchema(project) {
+  const config = project.config ?? {};
+  const stores = config.stores ?? structuredClone(standardStores);
+  const statuses = new Set(Object.values(stores).flatMap((store) => store.statuses));
+  const groups = { Active: [], Done: [], Archive: [] };
+  for (const status of statuses) {
+    const group = project.groups.get(status);
+    if (!group) fail('INVALID_CONFIG', `${project.schemaPath}: status ${status} needs an explicit activity group`);
+    groups[group].push(status);
+  }
+  // An undeclared pending default must remain implicit: making it explicit would
+  // turn a valid custom schema into an invalid one and inventing a status changes creation.
+  const defaults = statuses.has('pending') ? { default_status: 'pending' } : {};
+  const working = ['in_progress', 'review'].filter((status) => statuses.has(status));
+  const schema = {
+    format: 'standard', ...defaults,
+    ...(working.every((status) => project.groups.get(status) === 'Active') ? { working_statuses: working } : {}),
+    ...config, stores, groups, search: { ...defaultSearch, ...config.search },
+  };
+  if (jsonText(schema, 2, responseBytes - 1) === undefined) fail('OUTPUT_TOO_LARGE', 'effective schema exceeds the 32 KiB response budget');
+  return schema;
+}
+
+export function inspectSchema(projectPath, options = {}) {
+  checkOptions(options);
+  return effectiveSchema(openProject(projectPath, undefined, false, true, options.schemaPath));
+}
+
+export function materialiseSchema(projectPath, options = {}) {
+  checkOptions(options, true);
+  const initial = openProject(projectPath, undefined, false, true, options.schemaPath);
+  return withProjectLock(initial, 'schema materialisation', () => {
+    const project = openProject(initial.root, undefined, false, true, initial.schema);
+    const before = readText(project.schemaPath, readBudget(), true);
+    if (before !== undefined && !options.replace) {
+      fail('FILE_EXISTS', `${project.schemaPath}: schema already exists; explicitly request replacement`);
+    }
+    const schema = effectiveSchema(project);
+    // Empty projects can obtain a skeleton before their first task. Existing
+    // stores must already validate; materialisation never repairs task records.
+    const snapshot = retainedFiles(project).length ? scanProject(project.root, true, project.schema) : undefined;
+    const source = `${JSON.stringify(schema, null, 2)}\n`;
+    if (snapshot) {
+      if (Buffer.byteLength(source) - Buffer.byteLength(before ?? '') > snapshot.project.budget.remaining) {
+        fail('INPUT_TOO_LARGE', 'materialised schema would exceed the 8 MiB project source budget');
+      }
+      const current = scanProject(project.root, false, project.schema);
+      if (JSON.stringify(snapshot.fingerprints) !== JSON.stringify(current.fingerprints)) {
+        fail('PROJECT_CHANGED', 'task files or configuration changed during schema materialisation; retry after edits finish');
+      }
+    }
+    if (before !== readText(project.schemaPath, readBudget(), true)) {
+      fail('PROJECT_CHANGED', 'schema changed during materialisation; retry after edits finish');
+    }
+    const mode = before === undefined ? 0o600 : statSync(project.schemaPath).mode & 0o777;
+    replaceFile(project.schemaPath, source, mode, before === undefined);
+    return schema;
+  }, 5000);
+}

package/src/search-index-worker.mjs

@@ -0,0 +1,10 @@
+import { refreshSearchIndex } from './search-index.mjs';
+
+try {
+  const request = JSON.parse(process.argv[2]);
+  refreshSearchIndex(request.projectPath, {
+    schemaPath: request.schemaPath, lockClaimed: true, lockToken: request.lockToken,
+  });
+} catch {
+  process.exitCode = 1;
+}