[Init] Initial commit - NetMesh terminal manager

infrastructure/services/adapters/WebDAVAdapter.ts

@@ -0,0 +1,377 @@
+/**
+ * WebDAV Adapter - webdav client library
+ */
+
+import { AuthType, createClient } from 'webdav';
+import {
+  SYNC_CONSTANTS,
+  type WebDAVConfig,
+  type SyncedFile,
+  type ProviderAccount,
+  type OAuthTokens,
+} from '../../../domain/sync';
+import { netcattyBridge } from '../netcattyBridge';
+
+type WebDAVClient = ReturnType<typeof createClient>;
+
+const normalizeEndpoint = (endpoint: string): string => {
+  const trimmed = endpoint.trim();
+  if (!/^https?:\/\//i.test(trimmed)) {
+    return `https://${trimmed}`;
+  }
+  return trimmed;
+};
+
+const ensureLeadingSlash = (value: string): string =>
+  value.startsWith('/') ? value : `/${value}`;
+
+/**
+ * Recover from trailing garbage left by non-truncating WebDAV PUT overwrites
+ * (#2223). Node/V8: "Unexpected non-whitespace character after JSON at position N".
+ */
+const parseSyncedFileJson = (raw: string): SyncedFile => {
+  try {
+    return JSON.parse(raw) as SyncedFile;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const match = /Unexpected non-whitespace character after JSON at position (\d+)/i.exec(
+      message,
+    );
+    if (match) {
+      const pos = Number(match[1]);
+      if (Number.isFinite(pos) && pos > 0 && pos <= raw.length) {
+        return JSON.parse(raw.slice(0, pos)) as SyncedFile;
+      }
+    }
+    throw error;
+  }
+};
+
+const utf8ByteLength = (value: string): number =>
+  typeof Buffer !== 'undefined'
+    ? Buffer.byteLength(value, 'utf8')
+    : new TextEncoder().encode(value).length;
+
+/** Strict: intended body plus optional trailing whitespace only. */
+const remoteMatchesUploadedBody = (remoteText: string, body: string): boolean => {
+  if (!remoteText.startsWith(body)) return false;
+  return /^\s*$/.test(remoteText.slice(body.length));
+};
+
+/**
+ * Prefer fixed-name temp PUT + MOVE (with pad + verify); else padded in-place
+ * PUT with strict body match so non-truncating servers cannot leave garbage.
+ */
+const putWebdavFileReplacing = async (
+  client: WebDAVClient,
+  path: string,
+  body: string,
+): Promise<void> => {
+  const tmpPath = `${path}.tmp`;
+  const bodyLen = utf8ByteLength(body);
+
+  const cleanupTemp = async () => {
+    try {
+      if (await client.exists(tmpPath)) {
+        await client.deleteFile(tmpPath);
+      }
+    } catch {
+      // best-effort
+    }
+  };
+
+  const readLen = async (target: string): Promise<number> => {
+    let exists = false;
+    try {
+      exists = await client.exists(target);
+    } catch (error) {
+      throw new Error(
+        `WebDAV replace aborted: could not check existing file (${
+          error instanceof Error ? error.message : String(error)
+        })`,
+      );
+    }
+    if (!exists) return 0;
+    try {
+      const existing = await client.getFileContents(target, { format: 'text' });
+      if (existing == null) return 0;
+      return utf8ByteLength(String(existing));
+    } catch (error) {
+      throw new Error(
+        `WebDAV replace aborted: could not read existing file length (${
+          error instanceof Error ? error.message : String(error)
+        })`,
+      );
+    }
+  };
+
+  try {
+    let tmpMin = 0;
+    try {
+      tmpMin = await readLen(tmpPath);
+    } catch {
+      tmpMin = 0;
+    }
+    const tmpBody = tmpMin > bodyLen ? body + ' '.repeat(tmpMin - bodyLen) : body;
+    await client.putFileContents(tmpPath, tmpBody, { overwrite: true });
+    await client.moveFile(tmpPath, path, { overwrite: true });
+    const moved = String((await client.getFileContents(path, { format: 'text' })) ?? '');
+    if (remoteMatchesUploadedBody(moved, body)) {
+      return;
+    }
+  } catch {
+    // fall through
+  }
+  await cleanupTemp();
+
+  let minLen = await readLen(path);
+  minLen = Math.max(minLen, bodyLen);
+  for (let attempt = 0; attempt < 3; attempt++) {
+    const payload = minLen > bodyLen ? body + ' '.repeat(minLen - bodyLen) : body;
+    await client.putFileContents(path, payload, { overwrite: true });
+    let remoteText = '';
+    try {
+      remoteText = String((await client.getFileContents(path, { format: 'text' })) ?? '');
+    } catch (error) {
+      throw new Error(
+        `WebDAV upload verification failed: could not re-read file (${
+          error instanceof Error ? error.message : String(error)
+        })`,
+      );
+    }
+    if (remoteMatchesUploadedBody(remoteText, body)) {
+      return;
+    }
+    minLen = Math.max(minLen, utf8ByteLength(remoteText), bodyLen);
+  }
+  throw new Error(
+    'WebDAV upload verification failed: remote file still does not match uploaded body after padded PUT',
+  );
+};
+
+export class WebDAVAdapter {
+  private config: WebDAVConfig | null;
+  private resource: string | null;
+  private account: ProviderAccount | null;
+  private client: WebDAVClient | null;
+
+  constructor(config?: WebDAVConfig, resourceId?: string) {
+    this.config = config
+      ? { ...config, endpoint: normalizeEndpoint(config.endpoint) }
+      : null;
+    this.resource = resourceId || null;
+    this.account = this.buildAccountInfo(this.config);
+    this.client = this.config ? this.createClient(this.config) : null;
+  }
+
+  get isAuthenticated(): boolean {
+    return !!this.config;
+  }
+
+  get accountInfo(): ProviderAccount | null {
+    return this.account;
+  }
+
+  get resourceId(): string | null {
+    return this.resource;
+  }
+
+  signOut(): void {
+    this.config = null;
+    this.resource = null;
+    this.account = null;
+    this.client = null;
+  }
+
+  async initializeSync(): Promise<string | null> {
+    return this.withWebdavErrorContext('initialize', async () => {
+      if (!this.config) {
+        throw new Error('Missing WebDAV config');
+      }
+      const bridge = netcattyBridge.get();
+      if (bridge?.cloudSyncWebdavInitialize) {
+        const result = await bridge.cloudSyncWebdavInitialize(this.config);
+        this.resource = result?.resourceId || this.getSyncPath();
+        return this.resource;
+      }
+      const client = this.getClient();
+      const path = this.getSyncPath();
+      await client.exists(path);
+      this.resource = path;
+      return this.resource;
+    });
+  }
+
+  async upload(syncedFile: SyncedFile): Promise<string> {
+    return this.withWebdavErrorContext('upload', async () => {
+      if (!this.config) {
+        throw new Error('Missing WebDAV config');
+      }
+      const bridge = netcattyBridge.get();
+      if (bridge?.cloudSyncWebdavUpload) {
+        const result = await bridge.cloudSyncWebdavUpload(this.config, syncedFile);
+        this.resource = result?.resourceId || this.getSyncPath();
+        return this.resource;
+      }
+      const client = this.getClient();
+      const path = this.getSyncPath();
+      await putWebdavFileReplacing(client, path, JSON.stringify(syncedFile));
+      this.resource = path;
+      return path;
+    });
+  }
+
+  async download(): Promise<SyncedFile | null> {
+    return this.withWebdavErrorContext('download', async () => {
+      if (!this.config) {
+        throw new Error('Missing WebDAV config');
+      }
+      const bridge = netcattyBridge.get();
+      if (bridge?.cloudSyncWebdavDownload) {
+        const result = await bridge.cloudSyncWebdavDownload(this.config);
+        return (result?.syncedFile ?? null) as SyncedFile | null;
+      }
+      const client = this.getClient();
+      const path = this.getSyncPath();
+      const exists = await client.exists(path);
+      if (!exists) return null;
+      const data = await client.getFileContents(path, { format: 'text' });
+      if (!data) return null;
+      return parseSyncedFileJson(data as string);
+    });
+  }
+
+  async deleteSync(): Promise<void> {
+    return this.withWebdavErrorContext('delete', async () => {
+      if (!this.config) {
+        throw new Error('Missing WebDAV config');
+      }
+      const bridge = netcattyBridge.get();
+      if (bridge?.cloudSyncWebdavDelete) {
+        await bridge.cloudSyncWebdavDelete(this.config);
+        return;
+      }
+      const client = this.getClient();
+      const path = this.getSyncPath();
+      const exists = await client.exists(path);
+      if (!exists) return;
+      await client.deleteFile(path);
+    });
+  }
+
+  getTokens(): OAuthTokens | null {
+    return null;
+  }
+
+  private getClient(): WebDAVClient {
+    if (!this.config || !this.client) {
+      throw new Error('Missing WebDAV config');
+    }
+    return this.client;
+  }
+
+  private createClient(config: WebDAVConfig): WebDAVClient {
+    const extraOpts: Record<string, unknown> = {};
+    if (config.allowInsecure && typeof globalThis.process !== 'undefined') {
+      const https = require('https');
+      extraOpts.httpsAgent = new https.Agent({ rejectUnauthorized: false });
+    }
+
+    if (config.authType === 'token') {
+      return createClient(config.endpoint, {
+        authType: AuthType.Token,
+        token: {
+          access_token: config.token || '',
+          token_type: 'Bearer',
+        },
+        ...extraOpts,
+      });
+    }
+
+    if (config.authType === 'digest') {
+      return createClient(config.endpoint, {
+        authType: AuthType.Digest,
+        username: config.username || '',
+        password: config.password || '',
+        ...extraOpts,
+      });
+    }
+
+    return createClient(config.endpoint, {
+      authType: AuthType.Password,
+      username: config.username || '',
+      password: config.password || '',
+      ...extraOpts,
+    });
+  }
+
+  private async withWebdavErrorContext<T>(
+    operation: string,
+    fn: () => Promise<T>,
+  ): Promise<T> {
+    try {
+      return await fn();
+    } catch (error) {
+      throw this.buildWebdavError(operation, error);
+    }
+  }
+
+  private buildWebdavError(operation: string, error: unknown): Error {
+    const baseMessage = error instanceof Error ? error.message : String(error);
+    const details: Record<string, string | number | boolean | null | undefined> = {
+      operation,
+    };
+    const raw = error as {
+      status?: number;
+      statusText?: string;
+      url?: string;
+      method?: string;
+      code?: string;
+      response?: {
+        status?: number;
+        statusText?: string;
+        url?: string;
+      };
+      cause?: unknown;
+    };
+
+    if (raw?.status) details.status = raw.status;
+    if (raw?.statusText) details.statusText = raw.statusText;
+    if (raw?.url) details.url = raw.url;
+    if (raw?.method) details.method = raw.method;
+    if (raw?.code) details.code = raw.code;
+    if (raw?.response?.status) details.status = raw.response.status;
+    if (raw?.response?.statusText) details.statusText = raw.response.statusText;
+    if (raw?.response?.url) details.url = raw.response.url;
+    if (raw?.cause && typeof raw.cause === 'object') {
+      Object.assign(details, raw.cause as Record<string, unknown>);
+      details.operation = operation;
+      const cause = raw.cause as { code?: string };
+      if (cause?.code) details.causeCode = cause.code;
+    } else if (raw?.cause) {
+      details.cause = String(raw.cause);
+    }
+
+    const err = new Error(`WebDAV ${operation} failed: ${baseMessage}`);
+    (err as Error & { cause?: unknown }).cause = details;
+    return err;
+  }
+
+  private getSyncPath(): string {
+    return ensureLeadingSlash(SYNC_CONSTANTS.SYNC_FILE_NAME);
+  }
+
+  private buildAccountInfo(config: WebDAVConfig | null): ProviderAccount | null {
+    if (!config) return null;
+    try {
+      const url = new URL(config.endpoint);
+      const host = url.host;
+      const name = config.username ? `${config.username}@${host}` : host;
+      return { id: host, name };
+    } catch {
+      return { id: config.endpoint, name: config.endpoint };
+    }
+  }
+}
+
+export default WebDAVAdapter;