@buildifyx/desktop-agent 0.1.0

package/src/utils/credentials.js

@@ -0,0 +1,35 @@
+import { chmod, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+
+export const DEFAULT_CREDENTIALS_FILE = path.join(os.homedir(), '.buildifyx', 'credentials.json');
+
+export async function loadCredentials(filePath = DEFAULT_CREDENTIALS_FILE) {
+  try {
+    const raw = await readFile(filePath, 'utf8');
+    return JSON.parse(raw);
+  } catch (error) {
+    if (error?.code === 'ENOENT') return null;
+    throw error;
+  }
+}
+
+export async function saveCredentials(credentials, filePath = DEFAULT_CREDENTIALS_FILE) {
+  await mkdir(path.dirname(filePath), { recursive: true });
+  const temp = `${filePath}.tmp-${process.pid}-${Date.now()}`;
+  await writeFile(temp, `${JSON.stringify(credentials, null, 2)}\n`, { encoding: 'utf8', mode: 0o600 });
+  await chmod(temp, 0o600).catch(() => {});
+  await import('node:fs/promises').then(({ rename }) => rename(temp, filePath));
+  await chmod(filePath, 0o600).catch(() => {});
+  return filePath;
+}
+
+export async function clearCredentials(filePath = DEFAULT_CREDENTIALS_FILE) {
+  await rm(filePath, { force: true });
+}
+
+export function isCredentialExpired(credentials, now = Date.now()) {
+  if (!credentials?.expiresAt) return false;
+  const expiry = Date.parse(credentials.expiresAt);
+  return Number.isFinite(expiry) && expiry <= now;
+}

package/src/utils/text.js

@@ -0,0 +1,180 @@
+import { constants } from 'node:fs';
+import { access, open, rename, stat, unlink } from 'node:fs/promises';
+import path from 'node:path';
+import process from 'node:process';
+import { randomUUID } from 'node:crypto';
+
+export const MAX_TEXT_FILE_BYTES = 1024 * 1024;
+
+const utf8Decoder = new TextDecoder('utf-8', {
+  fatal: true,
+  ignoreBOM: true
+});
+
+export async function readUtf8File(filePath) {
+  const fileStat = await stat(filePath);
+
+  if (!fileStat.isFile()) {
+    throw new Error('The requested path is not a regular file.');
+  }
+  if (fileStat.size > MAX_TEXT_FILE_BYTES) {
+    throw new Error(`File exceeds the ${MAX_TEXT_FILE_BYTES}-byte limit.`);
+  }
+
+  const handle = await open(filePath, 'r');
+  try {
+    const buffer = await handle.readFile();
+    if (buffer.byteLength > MAX_TEXT_FILE_BYTES) {
+      throw new Error(`File exceeds the ${MAX_TEXT_FILE_BYTES}-byte limit.`);
+    }
+
+    try {
+      return utf8Decoder.decode(buffer);
+    } catch {
+      throw new Error('The requested file is not valid UTF-8 text.');
+    }
+  } finally {
+    await handle.close();
+  }
+}
+
+function getLines(content) {
+  const lines = [];
+  const newlinePattern = /\r\n|\n|\r/g;
+  let start = 0;
+  let match;
+
+  while ((match = newlinePattern.exec(content)) !== null) {
+    lines.push({
+      start,
+      contentEnd: match.index,
+      end: newlinePattern.lastIndex,
+      separator: match[0]
+    });
+    start = newlinePattern.lastIndex;
+  }
+
+  lines.push({ start, contentEnd: content.length, end: content.length, separator: '' });
+  return lines;
+}
+
+export function countTextLines(content) {
+  return getLines(content).length;
+}
+
+function assertLineNumber(lines, line, label) {
+  if (line < 1 || line > lines.length) {
+    throw new Error(`${label} must be between 1 and ${lines.length}.`);
+  }
+}
+
+export function replaceLines(content, startLine, endLine, replacementLines) {
+  const lines = getLines(content);
+  assertLineNumber(lines, startLine, 'startLine');
+  assertLineNumber(lines, endLine, 'endLine');
+
+  if (endLine < startLine) {
+    throw new Error('endLine must be greater than or equal to startLine.');
+  }
+  if (replacementLines.some((line) => /[\r\n]/.test(line))) {
+    throw new Error('Each replacement line must not contain newline characters.');
+  }
+
+  const first = lines[startLine - 1];
+  const last = lines[endLine - 1];
+  const preferredSeparator = lines.find((line) => line.separator)?.separator ?? '\n';
+  let replacement = replacementLines.join(preferredSeparator);
+
+  if (replacementLines.length > 0 && last.separator) {
+    replacement += last.separator;
+  }
+
+  return content.slice(0, first.start) + replacement + content.slice(last.end);
+}
+
+function characterOffset(content, position, label) {
+  const lines = getLines(content);
+  assertLineNumber(lines, position.line, `${label}.line`);
+
+  const selectedLine = lines[position.line - 1];
+  const lineContent = content.slice(selectedLine.start, selectedLine.contentEnd);
+  const characters = Array.from(lineContent);
+  const maxColumn = characters.length + 1;
+
+  if (position.column < 1 || position.column > maxColumn) {
+    throw new Error(`${label}.column must be between 1 and ${maxColumn}.`);
+  }
+
+  return selectedLine.start + characters.slice(0, position.column - 1).join('').length;
+}
+
+export function replaceCharacters(content, start, end, replacement) {
+  const startOffset = characterOffset(content, start, 'start');
+  const endOffset = characterOffset(content, end, 'end');
+
+  if (endOffset < startOffset) {
+    throw new Error('The end position must not come before the start position.');
+  }
+
+  return content.slice(0, startOffset) + replacement + content.slice(endOffset);
+}
+
+export async function createUtf8File(filePath, content) {
+  const byteLength = Buffer.byteLength(content, 'utf8');
+  if (byteLength > MAX_TEXT_FILE_BYTES) {
+    throw new Error(`File exceeds the ${MAX_TEXT_FILE_BYTES}-byte limit.`);
+  }
+
+  let handle;
+  try {
+    handle = await open(filePath, 'wx', 0o644);
+    await handle.writeFile(content, 'utf8');
+    await handle.sync();
+  } catch (error) {
+    if (error && typeof error === 'object' && error.code === 'EEXIST') {
+      throw new Error('File already exists.');
+    }
+    throw error;
+  } finally {
+    if (handle) {
+      await handle.close();
+    }
+  }
+}
+
+export async function writeUtf8FileAtomic(filePath, content) {
+  const byteLength = Buffer.byteLength(content, 'utf8');
+  if (byteLength > MAX_TEXT_FILE_BYTES) {
+    throw new Error(`Edited file exceeds the ${MAX_TEXT_FILE_BYTES}-byte limit.`);
+  }
+
+  const originalStat = await stat(filePath);
+  if (!originalStat.isFile()) {
+    throw new Error('The requested path is not a regular file.');
+  }
+  await access(filePath, constants.W_OK);
+
+  const directory = path.dirname(filePath);
+  const basename = path.basename(filePath);
+  const temporaryPath = path.join(directory, `.${basename}.buildifyx-${process.pid}-${randomUUID()}.tmp`);
+  let temporaryCreated = false;
+
+  try {
+    const handle = await open(temporaryPath, 'wx', originalStat.mode);
+    temporaryCreated = true;
+    try {
+      await handle.writeFile(content, 'utf8');
+      await handle.chmod(originalStat.mode);
+      await handle.sync();
+    } finally {
+      await handle.close();
+    }
+
+    await rename(temporaryPath, filePath);
+    temporaryCreated = false;
+  } finally {
+    if (temporaryCreated) {
+      await unlink(temporaryPath).catch(() => undefined);
+    }
+  }
+}

package/src/version.js

@@ -0,0 +1,111 @@
+import { readFile } from 'node:fs/promises';
+
+const packageJsonUrl = new URL('../package.json', import.meta.url);
+
+export async function getPackageMetadata() {
+  const content = await readFile(packageJsonUrl, 'utf8');
+  const metadata = JSON.parse(content);
+
+  return {
+    name: metadata.name,
+    version: metadata.version
+  };
+}
+
+function parseVersion(version) {
+  const normalized = version.trim().replace(/^v/, '');
+  const [core, prerelease = ''] = normalized.split('-', 2);
+  const parts = core.split('.').map((part) => Number(part));
+
+  if (parts.length !== 3 || parts.some((part) => !Number.isInteger(part) || part < 0)) {
+    return null;
+  }
+
+  return {
+    core: parts,
+    prerelease: prerelease ? prerelease.split('.') : []
+  };
+}
+
+function comparePrerelease(left, right) {
+  if (left.length === 0 && right.length === 0) return 0;
+  if (left.length === 0) return 1;
+  if (right.length === 0) return -1;
+
+  const length = Math.max(left.length, right.length);
+  for (let index = 0; index < length; index += 1) {
+    const a = left[index];
+    const b = right[index];
+
+    if (a === undefined) return -1;
+    if (b === undefined) return 1;
+    if (a === b) continue;
+
+    const aNumber = /^\d+$/.test(a) ? Number(a) : null;
+    const bNumber = /^\d+$/.test(b) ? Number(b) : null;
+
+    if (aNumber !== null && bNumber !== null) return aNumber > bNumber ? 1 : -1;
+    if (aNumber !== null) return -1;
+    if (bNumber !== null) return 1;
+    return a > b ? 1 : -1;
+  }
+
+  return 0;
+}
+
+export function compareVersions(leftVersion, rightVersion) {
+  const left = parseVersion(leftVersion);
+  const right = parseVersion(rightVersion);
+
+  if (!left || !right) {
+    return leftVersion === rightVersion ? 0 : null;
+  }
+
+  for (let index = 0; index < 3; index += 1) {
+    if (left.core[index] > right.core[index]) return 1;
+    if (left.core[index] < right.core[index]) return -1;
+  }
+
+  return comparePrerelease(left.prerelease, right.prerelease);
+}
+
+export async function getLatestNpmVersion(packageName, { timeoutMs = 2000 } = {}) {
+  const encodedName = packageName.replace('/', '%2f');
+  const response = await fetch(`https://registry.npmjs.org/${encodedName}/latest`, {
+    headers: {
+      accept: 'application/json'
+    },
+    signal: AbortSignal.timeout(timeoutMs)
+  });
+
+  if (!response.ok) {
+    throw new Error(`npm registry returned HTTP ${response.status}`);
+  }
+
+  const metadata = await response.json();
+  if (!metadata || typeof metadata.version !== 'string' || !metadata.version) {
+    throw new Error('npm registry response does not contain a version.');
+  }
+
+  return metadata.version;
+}
+
+export async function checkForUpdate(packageName, currentVersion, options) {
+  try {
+    const latestVersion = await getLatestNpmVersion(packageName, options);
+    const comparison = compareVersions(latestVersion, currentVersion);
+
+    return {
+      currentVersion,
+      latestVersion,
+      updateAvailable: comparison === 1
+    };
+  } catch (error) {
+    return {
+      currentVersion,
+      latestVersion: null,
+      updateAvailable: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}