@tonyclaw/agent-inspector 3.0.29 → 3.0.31

package/src/proxy/logger.ts

@@ -1,9 +1,31 @@
-import { readdir, stat, unlink, appendFile, mkdir } from "node:fs/promises";
-import { writeFileSync, mkdirSync } from "node:fs";
+import { Buffer } from "node:buffer";
+import { appendFileSync } from "node:fs";
+import { appendFile, readdir, rename, stat, unlink } from "node:fs/promises";
 import path from "node:path";
 import { getDataDir } from "./dataDir";
+import {
+  ensurePrivateDirectorySync,
+  PRIVATE_FILE_MODE,
+  securePrivateFileSync,
+  securePrivateTreeSync,
+} from "./privateDataPath";
 
-const RETENTION_DAYS = Number(process.env["LOG_RETENTION_DAYS"] ?? "7");
+const DAY_MS = 24 * 60 * 60 * 1000;
+const DEFAULT_RETENTION_DAYS = 7;
+const DEFAULT_APP_LOG_MAX_BYTES = 10 * 1024 * 1024;
+const DEFAULT_APP_LOG_MAX_FILES = 5;
+
+type ApplicationLogPolicy = {
+  maxBytes: number;
+  maxFiles: number;
+  retentionMs: number;
+};
+
+type ApplicationLogFile = {
+  generation: number;
+  modifiedAt: number;
+  path: string;
+};
 
 function writeStderrFallback(message: string, error: unknown): void {
   process.stderr.write(`${message} ${String(error)}\n`);
@@ -33,54 +55,283 @@ function getInspectorLogPath(): string {
   return path.join(getDataDir(), "logs", "inspector.log");
 }
 
+function readBoundedInteger(
+  name: string,
+  fallback: number,
+  minimum: number,
+  maximum: number,
+): number {
+  const raw = process.env[name];
+  if (raw === undefined || raw === "") return fallback;
+  const parsed = Number(raw);
+  if (!Number.isInteger(parsed) || parsed < minimum || parsed > maximum) return fallback;
+  return parsed;
+}
+
+function getApplicationLogPolicy(): ApplicationLogPolicy {
+  const retentionDays = readBoundedInteger("LOG_RETENTION_DAYS", DEFAULT_RETENTION_DAYS, 1, 3650);
+  return {
+    maxBytes: readBoundedInteger(
+      "AGENT_INSPECTOR_APP_LOG_MAX_BYTES",
+      DEFAULT_APP_LOG_MAX_BYTES,
+      1,
+      1024 * 1024 * 1024,
+    ),
+    maxFiles: readBoundedInteger(
+      "AGENT_INSPECTOR_APP_LOG_MAX_FILES",
+      DEFAULT_APP_LOG_MAX_FILES,
+      1,
+      100,
+    ),
+    retentionMs: retentionDays * DAY_MS,
+  };
+}
+
+function getRotatedGeneration(entry: string, baseName: string): number | null {
+  const prefix = `${baseName}.`;
+  if (!entry.startsWith(prefix)) return null;
+  const suffix = entry.slice(prefix.length);
+  if (!/^\d+$/.test(suffix)) return null;
+  const generation = Number(suffix);
+  if (!Number.isSafeInteger(generation) || generation < 1) return null;
+  return generation;
+}
+
+async function listApplicationLogFiles(logPath: string): Promise<ApplicationLogFile[]> {
+  const directory = path.dirname(logPath);
+  const baseName = path.basename(logPath);
+  const entries = await readdir(directory);
+  const files: ApplicationLogFile[] = [];
+
+  for (const entry of entries) {
+    const generation = entry === baseName ? 0 : getRotatedGeneration(entry, baseName);
+    if (generation === null) continue;
+    const filePath = path.join(directory, entry);
+    try {
+      const fileStat = await stat(filePath);
+      if (!fileStat.isFile()) continue;
+      files.push({ generation, modifiedAt: fileStat.mtimeMs, path: filePath });
+    } catch {
+      // The file may have been removed by another maintenance pass.
+    }
+  }
+
+  return files;
+}
+
+async function removeApplicationLog(filePath: string): Promise<boolean> {
+  try {
+    await stat(filePath);
+  } catch {
+    return true;
+  }
+  try {
+    await unlink(filePath);
+    return true;
+  } catch {
+    // Retention is best-effort; a later maintenance pass retries failed removals.
+    return false;
+  }
+}
+
+async function maintainApplicationLogs(
+  logPath: string,
+  policy: ApplicationLogPolicy,
+): Promise<boolean> {
+  const directory = path.dirname(logPath);
+  if (!ensurePrivateDirectorySync(directory)) return false;
+
+  let files: ApplicationLogFile[];
+  try {
+    files = await listApplicationLogFiles(logPath);
+  } catch {
+    return false;
+  }
+
+  for (const file of files) {
+    if (!securePrivateFileSync(file.path)) return false;
+  }
+
+  const cutoff = Date.now() - policy.retentionMs;
+  const retained = files.filter((file) => file.modifiedAt >= cutoff);
+  let maintained = true;
+  for (const file of files) {
+    if (file.modifiedAt < cutoff && !(await removeApplicationLog(file.path))) maintained = false;
+  }
+
+  const rotated = retained
+    .filter((file) => file.generation > 0)
+    .sort((left, right) => right.modifiedAt - left.modifiedAt);
+  const retainedRotatedCount = Math.max(0, policy.maxFiles - 1);
+  for (const file of rotated.slice(retainedRotatedCount)) {
+    if (!(await removeApplicationLog(file.path))) maintained = false;
+  }
+
+  return maintained;
+}
+
+async function moveApplicationLog(source: string, destination: string): Promise<boolean> {
+  try {
+    await stat(source);
+  } catch {
+    return true;
+  }
+  try {
+    await rename(source, destination);
+    if (!securePrivateFileSync(destination)) {
+      writeStderrFallback("[logger] Failed to secure rotated application log:", destination);
+      return false;
+    }
+    return true;
+  } catch (error) {
+    writeStderrFallback("[logger] Failed to rotate application log:", error);
+    return false;
+  }
+}
+
+async function rotateApplicationLog(logPath: string, maxFiles: number): Promise<boolean> {
+  if (maxFiles === 1) {
+    return await removeApplicationLog(logPath);
+  }
+
+  if (!(await removeApplicationLog(`${logPath}.${String(maxFiles - 1)}`))) return false;
+  for (let generation = maxFiles - 2; generation >= 1; generation -= 1) {
+    if (
+      !(await moveApplicationLog(
+        `${logPath}.${String(generation)}`,
+        `${logPath}.${String(generation + 1)}`,
+      ))
+    ) {
+      return false;
+    }
+  }
+  return await moveApplicationLog(logPath, `${logPath}.1`);
+}
+
+async function rotateApplicationLogIfNeeded(
+  logPath: string,
+  incomingBytes: number,
+  policy: ApplicationLogPolicy,
+): Promise<boolean> {
+  try {
+    const fileStat = await stat(logPath);
+    if (fileStat.size > 0 && fileStat.size + incomingBytes > policy.maxBytes) {
+      return await rotateApplicationLog(logPath, policy.maxFiles);
+    }
+    return true;
+  } catch {
+    // The active file does not exist yet.
+    return true;
+  }
+}
+
 export async function initLogger(): Promise<void> {
   const dir = resolveLogDir();
-  const retentionMs = RETENTION_DAYS * 24 * 60 * 60 * 1000;
-  const cutoff = Date.now() - retentionMs;
+  const policy = getApplicationLogPolicy();
+  const cutoff = Date.now() - policy.retentionMs;
 
   try {
-    await mkdir(dir, { recursive: true });
-    const entries = await readdir(dir);
-    for (const entry of entries) {
-      if (!entry.endsWith(".jsonl")) continue;
-      const fullPath = path.join(dir, entry);
-      try {
-        const s = await stat(fullPath);
-        if (s.mtimeMs < cutoff) {
-          await unlink(fullPath);
+    if (!ensurePrivateDirectorySync(dir)) {
+      writeStderrFallback("[logger] Failed to secure log directory:", dir);
+    } else if (!securePrivateTreeSync(dir)) {
+      writeStderrFallback("[logger] Failed to secure existing log files:", dir);
+    } else {
+      const entries = await readdir(dir);
+      for (const entry of entries) {
+        if (!entry.endsWith(".jsonl")) continue;
+        const fullPath = path.join(dir, entry);
+        try {
+          const s = await stat(fullPath);
+          if (s.mtimeMs < cutoff) {
+            await unlink(fullPath);
+          }
+        } catch {
+          // Skip files that can't be stat - not critical
         }
-      } catch {
-        // Skip files that can't be stat - not critical
       }
     }
   } catch (err) {
     // Log directory initialization errors but don't fail startup
     writeStderrFallback("[logger] Failed to initialize log directory:", err);
   }
+
+  const applicationLogPath = getInspectorLogPath();
+  if (!(await maintainApplicationLogs(applicationLogPath, policy))) {
+    writeStderrFallback(
+      "[logger] Failed to initialize application log lifecycle:",
+      applicationLogPath,
+    );
+  }
 }
 
 // File-based logger for application logs (not log entries)
-let loggerInitialized = false;
+let loggerInitialization: Promise<void> | null = null;
+let applicationLogWriteQueue: Promise<void> = Promise.resolve();
 
-async function writeAppLog(message: string): Promise<void> {
-  // Auto-initialize on first use if not already initialized
-  if (!loggerInitialized) {
-    loggerInitialized = true;
-    void initLogger();
-  }
+type ApplicationLogWriteResult = { ok: true } | { ok: false; reason: unknown };
 
-  const logPath = getInspectorLogPath();
+function ensureLoggerInitialized(): Promise<void> {
+  if (loggerInitialization === null) loggerInitialization = initLogger();
+  return loggerInitialization;
+}
+
+async function appendApplicationLogLine(
+  logPath: string,
+  line: string,
+  policy: ApplicationLogPolicy,
+): Promise<ApplicationLogWriteResult> {
+  const logDirPath = path.dirname(logPath);
+  if (!ensurePrivateDirectorySync(logDirPath)) {
+    return { ok: false, reason: "application log directory is not private" };
+  }
   try {
-    const logDirPath = path.dirname(logPath);
-    await mkdir(logDirPath, { recursive: true });
-    const timestamp = new Date().toISOString();
-    await appendFile(logPath, `[${timestamp}] ${message}\n`, "utf-8");
-  } catch (err) {
-    // Log to stderr since file logging failed
-    writeStderrFallback(`[logger] Failed to write to ${logPath}:`, err);
+    if (!(await rotateApplicationLogIfNeeded(logPath, Buffer.byteLength(line, "utf-8"), policy))) {
+      return { ok: false, reason: "application log rotation failed" };
+    }
+    await appendFile(logPath, line, { encoding: "utf-8", mode: PRIVATE_FILE_MODE });
+    if (!securePrivateFileSync(logPath)) {
+      return { ok: false, reason: "application log permissions could not be secured" };
+    }
+    return { ok: true };
+  } catch (error) {
+    return { ok: false, reason: error };
   }
 }
 
+/** Isolated lifecycle hook used by the rotation tests without mutating process-wide environment. */
+export async function appendApplicationLogLineForTests(
+  logPath: string,
+  line: string,
+  maxBytes: number,
+  maxFiles: number,
+): Promise<boolean> {
+  const result = await appendApplicationLogLine(logPath, line, {
+    maxBytes,
+    maxFiles,
+    retentionMs: DEFAULT_RETENTION_DAYS * DAY_MS,
+  });
+  return result.ok;
+}
+
+async function writeAppLog(message: string): Promise<void> {
+  const logPath = getInspectorLogPath();
+  const line = `[${new Date().toISOString()}] ${message}\n`;
+  const initialization = ensureLoggerInitialized();
+  const write = async (): Promise<void> => {
+    await initialization;
+    const result = await appendApplicationLogLine(logPath, line, getApplicationLogPolicy());
+    if (!result.ok) writeStderrFallback(`[logger] Failed to write to ${logPath}:`, result.reason);
+  };
+
+  applicationLogWriteQueue = applicationLogWriteQueue.then(write, write);
+  await applicationLogWriteQueue;
+}
+
+/** Wait for all queued application-log writes and rotations. */
+export async function flushApplicationLog(): Promise<void> {
+  await applicationLogWriteQueue;
+}
+
 // Application logger - writes to inspector.log
 export const logger = {
   debug(message: string, ...args: unknown[]): void {
@@ -137,8 +388,15 @@ async function flushWriteBufferUnlocked(): Promise<void> {
 
   try {
     const filePath = getLogFilePath();
-    await mkdir(path.dirname(filePath), { recursive: true });
-    await appendFile(filePath, toWrite, "utf-8");
+    if (!ensurePrivateDirectorySync(path.dirname(filePath))) {
+      writeBuffer.unshift(toWrite);
+      writeStderrFallback("[logger] Failed to secure captured-log directory:", filePath);
+      return;
+    }
+    await appendFile(filePath, toWrite, { encoding: "utf-8", mode: PRIVATE_FILE_MODE });
+    if (!securePrivateFileSync(filePath)) {
+      writeStderrFallback("[logger] Failed to secure captured-log file:", filePath);
+    }
   } catch (err) {
     // On failure, re-queue the data so it is not lost
     writeBuffer.unshift(toWrite);
@@ -182,16 +440,11 @@ process.on("exit", () => {
     try {
       // Synchronous write required in 'exit' handler (async I/O not allowed)
       const filePath = getLogFilePath();
-      mkdirSync(path.dirname(filePath), { recursive: true });
-      writeFileSync(filePath, toWrite, "utf-8");
+      if (!ensurePrivateDirectorySync(path.dirname(filePath))) return;
+      appendFileSync(filePath, toWrite, { encoding: "utf-8", mode: PRIVATE_FILE_MODE });
+      void securePrivateFileSync(filePath);
     } catch {
       // Best-effort: nothing we can do in an exit handler
     }
   }
 });
-
-for (const signal of ["SIGINT", "SIGTERM"] as const) {
-  process.on(signal, () => {
-    void flushLogBuffer().then(() => process.exit(0));
-  });
-}

package/src/proxy/privateDataPath.ts

@@ -0,0 +1,183 @@
+import { spawnSync } from "node:child_process";
+import { chmodSync, existsSync, lstatSync, mkdirSync, readdirSync, statSync } from "node:fs";
+import { dirname, join } from "node:path";
+
+export const PRIVATE_DIRECTORY_MODE = 0o700;
+export const PRIVATE_FILE_MODE = 0o600;
+
+export type PrivateDataPathKind = "directory" | "file";
+
+type WindowsCommandResult = {
+  status: number | null;
+  stdout: string;
+};
+
+export type WindowsCommandRunner = (
+  executable: string,
+  args: readonly string[],
+) => WindowsCommandResult;
+
+const securedPaths = new Set<string>();
+const securedFileIdentities = new Map<string, string>();
+let cachedWindowsSid: string | null = null;
+
+function runWindowsCommand(executable: string, args: readonly string[]): WindowsCommandResult {
+  const result = spawnSync(executable, [...args], {
+    encoding: "utf8",
+    shell: false,
+    windowsHide: true,
+  });
+  return { status: result.status, stdout: result.stdout };
+}
+
+function windowsUserSid(output: string): string | null {
+  const match = /S-\d+(?:-\d+)+/.exec(output);
+  return match?.[0] ?? null;
+}
+
+function resolveWindowsUserSid(run: WindowsCommandRunner): string | null {
+  if (run === runWindowsCommand && cachedWindowsSid !== null) return cachedWindowsSid;
+  const identity = run("whoami.exe", ["/user", "/fo", "csv", "/nh"]);
+  if (identity.status !== 0) return null;
+  const sid = windowsUserSid(identity.stdout);
+  if (run === runWindowsCommand) cachedWindowsSid = sid;
+  return sid;
+}
+
+function windowsBroadGroupRemovalArgs(): readonly string[] {
+  return ["/remove:g", "*S-1-1-0", "*S-1-5-11", "*S-1-5-32-545"];
+}
+
+/**
+ * Remove inherited Windows permissions and grant full control only to the
+ * account that owns the current process. Commands are executed directly,
+ * never through a shell, and no path content is interpreted as command text.
+ */
+export function applyWindowsUserOnlyAcl(
+  path: string,
+  kind: PrivateDataPathKind,
+  run: WindowsCommandRunner = runWindowsCommand,
+): boolean {
+  const sid = resolveWindowsUserSid(run);
+  if (sid === null) return false;
+
+  const access = kind === "directory" ? `(OI)(CI)F` : "F";
+  const result = run("icacls.exe", [
+    path,
+    "/inheritance:r",
+    "/grant:r",
+    `*${sid}:${access}`,
+    ...windowsBroadGroupRemovalArgs(),
+    "/q",
+  ]);
+  return result.status === 0;
+}
+
+/** Apply a user-only ACL to an existing Windows tree in one bounded process. */
+export function applyWindowsUserOnlyTreeAcl(
+  root: string,
+  run: WindowsCommandRunner = runWindowsCommand,
+): boolean {
+  const sid = resolveWindowsUserSid(run);
+  if (sid === null) return false;
+  const result = run("icacls.exe", [
+    root,
+    "/inheritance:r",
+    "/grant:r",
+    `*${sid}:(OI)(CI)F`,
+    `*${sid}:F`,
+    ...windowsBroadGroupRemovalArgs(),
+    "/T",
+    "/C",
+    "/Q",
+  ]);
+  return result.status === 0;
+}
+
+function applyPrivatePermissionsSync(path: string, kind: PrivateDataPathKind): boolean {
+  if (process.platform === "win32") {
+    return applyWindowsUserOnlyAcl(path, kind);
+  }
+
+  try {
+    chmodSync(path, kind === "directory" ? PRIVATE_DIRECTORY_MODE : PRIVATE_FILE_MODE);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function secureOnce(path: string, kind: PrivateDataPathKind): boolean {
+  const cacheKey = `${kind}:${path}`;
+  if (securedPaths.has(cacheKey)) return true;
+  if (!applyPrivatePermissionsSync(path, kind)) return false;
+  securedPaths.add(cacheKey);
+  return true;
+}
+
+export function ensurePrivateDirectorySync(path: string): boolean {
+  try {
+    mkdirSync(path, { recursive: true, mode: PRIVATE_DIRECTORY_MODE });
+  } catch {
+    return false;
+  }
+  return secureOnce(path, "directory");
+}
+
+export function securePrivateFileSync(path: string, forceAcl = false): boolean {
+  let identity: string;
+  try {
+    const stats = statSync(path);
+    identity = `${String(stats.dev)}:${String(stats.ino)}:${String(stats.birthtimeMs)}`;
+  } catch {
+    return false;
+  }
+  if (securedFileIdentities.get(path) === identity) return true;
+  if (process.platform === "win32" && !forceAcl && securedPaths.has(`directory:${dirname(path)}`)) {
+    securedFileIdentities.set(path, identity);
+    return true;
+  }
+  if (!applyPrivatePermissionsSync(path, "file")) return false;
+  securedFileIdentities.set(path, identity);
+  return true;
+}
+
+/** Secure an existing tree without following symbolic links. */
+export function securePrivateTreeSync(root: string): boolean {
+  if (!existsSync(root)) return false;
+
+  let stats: ReturnType<typeof lstatSync>;
+  try {
+    stats = lstatSync(root);
+  } catch {
+    return false;
+  }
+  if (stats.isSymbolicLink()) return true;
+  if (!stats.isDirectory()) return securePrivateFileSync(root, true);
+  if (process.platform === "win32") {
+    if (!applyWindowsUserOnlyTreeAcl(root)) return false;
+    securedPaths.add(`directory:${root}`);
+    return true;
+  }
+  if (!ensurePrivateDirectorySync(root)) return false;
+
+  let entries: string[];
+  try {
+    entries = readdirSync(root);
+  } catch {
+    return false;
+  }
+
+  let secured = true;
+  for (const entry of entries) {
+    const childPath = join(root, entry);
+    if (!securePrivateTreeSync(childPath)) secured = false;
+  }
+  return secured;
+}
+
+export function _resetPrivateDataPathCacheForTests(): void {
+  securedPaths.clear();
+  securedFileIdentities.clear();
+  cachedWindowsSid = null;
+}

package/src/proxy/providerScanStore.ts

@@ -0,0 +1,87 @@
+import { randomUUID } from "node:crypto";
+import { maskApiKey } from "../lib/mask";
+import type { ScannedProviderDto } from "../lib/providerImportContract";
+import type { ExternalProvider } from "./providerImporters";
+
+const SCAN_TTL_MS = 5 * 60 * 1000;
+const MAX_ACTIVE_SCANS = 8;
+const MAX_SCANNED_PROVIDERS = 100;
+
+type ProviderScanSession = {
+  expiresAt: number;
+  providers: ReadonlyMap<string, ExternalProvider>;
+};
+
+const sessions = new Map<string, ProviderScanSession>();
+
+function removeExpired(now: number): void {
+  for (const [scanId, session] of sessions) {
+    if (session.expiresAt <= now) sessions.delete(scanId);
+  }
+}
+
+function enforceSessionLimit(): void {
+  while (sessions.size >= MAX_ACTIVE_SCANS) {
+    const oldest = sessions.keys().next().value;
+    if (typeof oldest !== "string") return;
+    sessions.delete(oldest);
+  }
+}
+
+export function createProviderScan(
+  providers: readonly ExternalProvider[],
+  now = Date.now(),
+): { scanId: string; providers: ScannedProviderDto[] } {
+  removeExpired(now);
+  enforceSessionLimit();
+
+  const scanId = randomUUID();
+  const providerMap = new Map<string, ExternalProvider>();
+  const redacted: ScannedProviderDto[] = [];
+  for (const provider of providers.slice(0, MAX_SCANNED_PROVIDERS)) {
+    const selectionId = randomUUID();
+    providerMap.set(selectionId, provider);
+    redacted.push({
+      selectionId,
+      name: provider.name,
+      apiKeyHint: maskApiKey(provider.apiKey),
+      format: provider.format,
+      anthropicBaseUrl: provider.anthropicBaseUrl,
+      openaiBaseUrl: provider.openaiBaseUrl,
+      openaiResponsesBaseUrl: provider.openaiResponsesBaseUrl,
+      models: provider.models,
+      sourceTool: provider.sourceTool,
+      alreadyExists: provider.alreadyExists,
+    });
+  }
+
+  sessions.set(scanId, {
+    expiresAt: now + SCAN_TTL_MS,
+    providers: providerMap,
+  });
+  return { scanId, providers: redacted };
+}
+
+export function consumeProviderScan(
+  scanId: string,
+  selectionIds: readonly string[],
+  now = Date.now(),
+): ExternalProvider[] | null {
+  removeExpired(now);
+  const session = sessions.get(scanId);
+  if (session === undefined) return null;
+  sessions.delete(scanId);
+
+  const uniqueIds = new Set(selectionIds);
+  const selected: ExternalProvider[] = [];
+  for (const selectionId of uniqueIds) {
+    const provider = session.providers.get(selectionId);
+    if (provider === undefined) return null;
+    selected.push(provider);
+  }
+  return selected;
+}
+
+export function _resetProviderScanStoreForTests(): void {
+  sessions.clear();
+}