borgmcp 4.4.0 → 4.5.1

package/src/opencode-drone.ts

@@ -1,8 +1,26 @@
-import { appendFileSync, chmodSync, existsSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync } from 'fs';
-import { createHash } from 'crypto';
+import {
+  closeSync,
+  constants,
+  existsSync,
+  fchmodSync,
+  fstatSync,
+  openSync,
+  readFileSync,
+  readSync,
+  renameSync,
+  unlinkSync,
+  writeFileSync,
+  writeSync,
+} from 'fs';
+import { createHash, randomUUID } from 'crypto';
 import { createServer } from 'node:net';
 import { join } from 'path';
 import { tmpdir } from 'os';
+import {
+  borgConfigRoot,
+  ensurePrivateBorgConfigRoot,
+  ensurePrivateBorgConfigRootSync,
+} from './private-root.js';
 import {
   OPENCODE_INJECTED_ENTRY_METADATA_KEY,
   OPENCODE_WAKE_IDENTITY_METADATA_KEY,
@@ -30,37 +48,115 @@ function stateIdentityDigest(current: OpenCodeDroneState): string {
   return createHash('sha256').update(key).digest('hex').slice(0, 24);
 }
 
-function diagnosticLogPath(owner: OpenCodeDroneState): string {
-  const path = join(tmpdir(), `borg-opencode-drone-${stateIdentityDigest(owner)}.log`);
+export function openCodeStartupDiagnosticLogPath(): string {
+  return join(borgConfigRoot(), 'opencode-drone-startup.log');
+}
+
+function diagnosticLogPath(owner: OpenCodeDroneState | null): string {
+  const root = borgConfigRoot();
+  const path = owner
+    ? join(root, `opencode-drone-${stateIdentityDigest(owner)}.log`)
+    : openCodeStartupDiagnosticLogPath();
   diagnosticLogPathsForTests.add(path);
   return path;
 }
 
-function log(msg: string, owner: OpenCodeDroneState | null = state) {
+function log(msg: string, owner: OpenCodeDroneState | null = state, throwOnFailure = false) {
   const line = `[${new Date().toISOString()}] ${msg}\n`;
-  if (!owner) {
-    process.stderr.write(line);
-    return;
-  }
+  let descriptor: number | null = null;
+  let temporaryDescriptor: number | null = null;
+  let temporary: string | null = null;
   try {
+    ensurePrivateBorgConfigRootSync(borgConfigRoot());
     const path = diagnosticLogPath(owner);
-    if (existsSync(path)) chmodSync(path, 0o600);
-    appendFileSync(path, line, { encoding: 'utf8', mode: 0o600 });
-    chmodSync(path, 0o600);
-    if (statSync(path).size <= OPEN_CODE_DIAGNOSTIC_LOG_MAX_BYTES) return;
-    const contents = readFileSync(path);
-    const tail = contents.subarray(contents.length - OPEN_CODE_DIAGNOSTIC_LOG_MAX_BYTES);
-    const firstNewline = tail.indexOf(0x0a);
-    const bounded = firstNewline >= 0 ? tail.subarray(firstNewline + 1) : tail;
-    const temporary = `${path}.${process.pid}.tmp`;
-    writeFileSync(temporary, bounded, { mode: 0o600 });
+    // The private root is the primary boundary. Where available, no-follow also
+    // closes the final replacement gap between root verification and this open.
+    const noFollow = constants.O_NOFOLLOW ?? 0;
+    descriptor = openSync(
+      path,
+      constants.O_RDWR |
+        constants.O_APPEND |
+        constants.O_CREAT |
+        noFollow,
+      0o600,
+    );
+    if (!fstatSync(descriptor).isFile()) {
+      throw Object.assign(new Error('OpenCode diagnostic log is not a regular file'), { code: 'EINVAL' });
+    }
+    fchmodSync(descriptor, 0o600);
+    writeSync(descriptor, line, null, 'utf8');
+
+    const size = fstatSync(descriptor).size;
+    if (size <= OPEN_CODE_DIAGNOSTIC_LOG_MAX_BYTES) return;
+    const tail = Buffer.allocUnsafe(OPEN_CODE_DIAGNOSTIC_LOG_MAX_BYTES);
+    let bytesRead = 0;
+    while (bytesRead < tail.length) {
+      const count = readSync(
+        descriptor,
+        tail,
+        bytesRead,
+        tail.length - bytesRead,
+        size - tail.length + bytesRead,
+      );
+      if (count === 0) break;
+      bytesRead += count;
+    }
+    const completeTail = tail.subarray(0, bytesRead);
+    const firstNewline = completeTail.indexOf(0x0a);
+    const bounded = firstNewline >= 0 ? completeTail.subarray(firstNewline + 1) : completeTail;
+
+    temporary = `${path}.${randomUUID()}.tmp`;
+    temporaryDescriptor = openSync(
+      temporary,
+      constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | noFollow,
+      0o600,
+    );
+    if (!fstatSync(temporaryDescriptor).isFile()) {
+      throw Object.assign(new Error('OpenCode diagnostic temporary is not a regular file'), { code: 'EINVAL' });
+    }
+    fchmodSync(temporaryDescriptor, 0o600);
+    let bytesWritten = 0;
+    while (bytesWritten < bounded.length) {
+      const count = writeSync(
+        temporaryDescriptor,
+        bounded,
+        bytesWritten,
+        bounded.length - bytesWritten,
+      );
+      if (count === 0) throw Object.assign(new Error('OpenCode diagnostic temporary write stalled'), { code: 'EIO' });
+      bytesWritten += count;
+    }
+    closeSync(temporaryDescriptor);
+    temporaryDescriptor = null;
+    closeSync(descriptor);
+    descriptor = null;
     renameSync(temporary, path);
+    temporary = null;
   } catch (error) {
     const code = (error as NodeJS.ErrnoException | null)?.code ?? 'unknown';
     process.stderr.write(`OpenCode diagnostic log write failed (${code})\n`);
+    if (throwOnFailure) throw error;
+  } finally {
+    if (temporaryDescriptor !== null) {
+      try { closeSync(temporaryDescriptor); } catch { /* The primary write error is already reported. */ }
+    }
+    if (descriptor !== null) {
+      try { closeSync(descriptor); } catch { /* The primary write error is already reported. */ }
+    }
+    if (temporary !== null) {
+      try {
+        unlinkSync(temporary);
+      } catch {
+        // Already absent or inaccessible; the randomized name cannot be reused.
+      }
+    }
   }
 }
 
+export function writeOpenCodeStartupDiagnostic(message: string): void {
+  log(message, null, true);
+}
+
 interface OpenCodeDroneState {
   serverUrl: string;
   apiPassword: string;
@@ -229,6 +325,7 @@ export async function connectOpenCodeDrone(deps: ConnectDeps): Promise<void> {
   if (!isOpenCode256BitIdentity(deps.apiPassword)) {
     throw new OpenCodeAuthenticationError('OpenCode API password is missing or unverifiable');
   }
+  await ensurePrivateBorgConfigRoot(borgConfigRoot());
   abandonOpenCodeDeliveries(state);
   state = {
     serverUrl: deps.serverUrl,

package/src/private-root.ts

@@ -1,4 +1,4 @@
-import { lstatSync, realpathSync } from 'node:fs';
+import fs, { lstatSync, realpathSync } from 'node:fs';
 import { chmod, lstat, mkdir } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { dirname, isAbsolute, join, resolve } from 'node:path';
@@ -100,3 +100,40 @@ export async function ensurePrivateBorgConfigRoot(root = borgConfigRoot()): Prom
     throw new Error('Borg private-state directory is not private');
   }
 }
+
+/** Synchronous equivalent for startup-failure paths that must never await. */
+export function ensurePrivateBorgConfigRootSync(root = borgConfigRoot()): void {
+  if (!isAbsolute(root) || resolve(root) !== root) {
+    throw new Error('Borg private-state directory path is not canonical');
+  }
+
+  let metadata: fs.Stats;
+  try {
+    metadata = fs.lstatSync(root);
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error;
+    fs.mkdirSync(root, { recursive: true, mode: 0o700 });
+    metadata = fs.lstatSync(root);
+  }
+
+  if (metadata.isSymbolicLink() || !metadata.isDirectory()) {
+    throw new Error('Borg private-state directory must be a real directory');
+  }
+  const uid = typeof process.getuid === 'function' ? process.getuid() : null;
+  if (uid !== null && metadata.uid !== uid) {
+    throw new Error('Borg private-state directory is not owned by the current user');
+  }
+
+  const mode = metadata.mode & 0o777;
+  if ((mode & 0o022) !== 0) {
+    throw new Error('Borg private-state directory is writable by other users');
+  }
+  if (mode !== 0o700) {
+    fs.chmodSync(root, 0o700);
+  }
+
+  const final = fs.lstatSync(root);
+  if (!final.isDirectory() || (final.mode & 0o777) !== 0o700) {
+    throw new Error('Borg private-state directory is not private');
+  }
+}

package/src/terminal-title.ts

@@ -32,6 +32,8 @@
  *     populated," so the assimilated path is the common case.
  */
 
+import { escapeSyncDisplay } from './sync-roles-render.js';
+
 /**
  * Pure: compose the title string for a session. Exported so tests can
  * exercise every branch without TTY / process / fs dependencies.
@@ -46,9 +48,9 @@ export function composeTerminalTitle(
   repoBasename: string
 ): string {
   if (activeDrone) {
-    return `borg · ${activeDrone.label} · ${activeDrone.cubeName}`;
+    return `borg · ${escapeSyncDisplay(activeDrone.label)} · ${escapeSyncDisplay(activeDrone.cubeName)}`;
   }
-  return `borg · ${repoBasename}`;
+  return `borg · ${escapeSyncDisplay(repoBasename)}`;
 }
 
 /**