@clawpilot-app/link 0.1.0

package/src/runtime.js

@@ -0,0 +1,423 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import fsp from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+
+const HOME_DIR = os.homedir();
+const BASE_DIR = path.join(HOME_DIR, ".clawpilot", "link");
+const RUN_DIR = path.join(BASE_DIR, "run");
+const LOG_DIR = path.join(BASE_DIR, "logs");
+const CACHE_DIR = path.join(BASE_DIR, "cache");
+const FILE_LOCK_STALE_MS = 15_000;
+const FILE_LOCK_TIMEOUT_MS = 8_000;
+const FILE_LOCK_RETRY_MS = 40;
+const LOG_ROTATION_MAX_BYTES = 5 * 1024 * 1024;
+const LOG_ROTATION_BACKUP_COUNT = 3;
+
+export const runtimePaths = Object.freeze({
+  baseDir: BASE_DIR,
+  runDir: RUN_DIR,
+  logDir: LOG_DIR,
+  cacheDir: CACHE_DIR,
+  configFile: path.join(BASE_DIR, "config.json"),
+  stateFile: path.join(BASE_DIR, "state.json"),
+  credentialsFile: path.join(BASE_DIR, "credentials.json"),
+  logFile: path.join(LOG_DIR, "current.log"),
+  stateLockFile: path.join(RUN_DIR, "state.lock"),
+  credentialsLockFile: path.join(RUN_DIR, "credentials.lock"),
+  logLockFile: path.join(RUN_DIR, "log.lock"),
+  socketFile:
+    process.platform === "win32"
+      ? `\\\\.\\pipe\\clawpilot-link-${crypto.createHash("sha1").update(BASE_DIR).digest("hex").slice(0, 12)}`
+      : path.join(RUN_DIR, "daemon.sock"),
+});
+
+export function randomId(prefix) {
+  return `${prefix}${crypto.randomUUID().replace(/-/g, "")}`;
+}
+
+function randomSecret(byteLength = 24) {
+  return crypto.randomBytes(byteLength).toString("base64url");
+}
+
+export function encodeBase64UrlJson(value) {
+  return Buffer.from(JSON.stringify(value), "utf8")
+    .toString("base64")
+    .replace(/\+/g, "-")
+    .replace(/\//g, "_")
+    .replace(/=+$/g, "");
+}
+
+export async function ensureRuntimeLayout() {
+  await Promise.all([
+    fsp.mkdir(runtimePaths.baseDir, { recursive: true }),
+    fsp.mkdir(runtimePaths.runDir, { recursive: true }),
+    fsp.mkdir(runtimePaths.logDir, { recursive: true }),
+    fsp.mkdir(runtimePaths.cacheDir, { recursive: true }),
+  ]);
+}
+
+async function readJsonFile(filePath) {
+  try {
+    const raw = await fsp.readFile(filePath, "utf8");
+    return JSON.parse(raw);
+  } catch (error) {
+    if (error && typeof error === "object" && error.code === "ENOENT") {
+      return null;
+    }
+    throw error;
+  }
+}
+
+async function writeJsonFile(filePath, value) {
+  await ensureRuntimeLayout();
+  const tempPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+  await fsp.writeFile(tempPath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+  await fsp.rename(tempPath, filePath);
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function acquireFileLock(lockPath, options = {}) {
+  await ensureRuntimeLayout();
+  const staleMs = Number.isFinite(options.staleMs) ? options.staleMs : FILE_LOCK_STALE_MS;
+  const timeoutMs = Number.isFinite(options.timeoutMs) ? options.timeoutMs : FILE_LOCK_TIMEOUT_MS;
+  const retryMs = Number.isFinite(options.retryMs) ? options.retryMs : FILE_LOCK_RETRY_MS;
+  const startedAt = Date.now();
+
+  while (true) {
+    try {
+      const handle = await fsp.open(lockPath, "wx");
+      await handle.writeFile(
+        JSON.stringify({
+          pid: process.pid,
+          lockedAt: new Date().toISOString(),
+        }),
+        "utf8",
+      );
+      return handle;
+    } catch (error) {
+      if (!error || typeof error !== "object" || error.code !== "EEXIST") {
+        throw error;
+      }
+
+      try {
+        const stats = await fsp.stat(lockPath);
+        if (Date.now() - stats.mtimeMs > staleMs) {
+          await fsp.unlink(lockPath);
+          continue;
+        }
+      } catch (statError) {
+        if (statError && typeof statError === "object" && statError.code === "ENOENT") {
+          continue;
+        }
+        throw statError;
+      }
+
+      if (Date.now() - startedAt > timeoutMs) {
+        throw new Error(`lock_timeout:${path.basename(lockPath)}`);
+      }
+
+      await sleep(retryMs);
+    }
+  }
+}
+
+async function withFileLock(lockPath, fn, options = {}) {
+  const handle = await acquireFileLock(lockPath, options);
+  try {
+    return await fn();
+  } finally {
+    await handle.close().catch(() => undefined);
+    await fsp.unlink(lockPath).catch(() => undefined);
+  }
+}
+
+export function buildDefaultConfig() {
+  return {
+    installId: randomId("cplink_install_"),
+    displayName: os.hostname() || "ClawPilot Link",
+    language: "auto",
+    apiBaseUrl: "https://api.clawpilot.me",
+    relayBaseUrl: "https://relay.clawpilot.me",
+    directAccessKey: randomSecret(),
+    autoStartAfterPair: true,
+  };
+}
+
+export function buildDefaultState() {
+  return {
+    connectionStatus: "new",
+    lastErrorMessage: null,
+    linkId: null,
+    pairingSession: null,
+    daemon: {
+      pid: null,
+      startedAt: null,
+      connectedAt: null,
+      lastHeartbeatAt: null,
+    },
+    backend: {
+      detected: false,
+      healthy: false,
+      supported: false,
+      message: null,
+      configPath: null,
+      httpBaseUrl: null,
+      wsEndpoint: null,
+      authType: null,
+      source: null,
+      port: null,
+      checkedAt: null,
+    },
+    directAccess: {
+      status: "unknown",
+      port: null,
+      reason: null,
+      message: null,
+      checkedAt: null,
+    },
+    updatedAt: new Date().toISOString(),
+  };
+}
+
+export async function loadConfig() {
+  await ensureRuntimeLayout();
+  const existing = await readJsonFile(runtimePaths.configFile);
+  if (existing && typeof existing === "object" && !Array.isArray(existing)) {
+    const merged = {
+      ...buildDefaultConfig(),
+      ...existing,
+    };
+    const normalizedRelayBaseUrl = normalizeHttpsBaseUrl(merged.relayBaseUrl);
+    if (normalizedRelayBaseUrl) {
+      merged.relayBaseUrl = normalizedRelayBaseUrl;
+    }
+    return {
+      ...merged,
+    };
+  }
+  const created = buildDefaultConfig();
+  await writeJsonFile(runtimePaths.configFile, created);
+  return created;
+}
+
+export async function saveConfig(config) {
+  await writeJsonFile(runtimePaths.configFile, config);
+}
+
+function normalizeStateSnapshot(state) {
+  return {
+    ...buildDefaultState(),
+    ...state,
+    daemon: {
+      ...buildDefaultState().daemon,
+      ...(state.daemon ?? {}),
+    },
+    backend: {
+      ...buildDefaultState().backend,
+      ...(state.backend ?? {}),
+    },
+    directAccess: {
+      ...buildDefaultState().directAccess,
+      ...(state.directAccess ?? {}),
+    },
+  };
+}
+
+export async function loadState() {
+  await ensureRuntimeLayout();
+  const existing = await readJsonFile(runtimePaths.stateFile);
+  if (existing && typeof existing === "object" && !Array.isArray(existing)) {
+    return normalizeStateSnapshot(existing);
+  }
+  const created = buildDefaultState();
+  await writeJsonFile(runtimePaths.stateFile, created);
+  return created;
+}
+
+async function saveStateUnlocked(state) {
+  const nextState = {
+    ...normalizeStateSnapshot(state),
+    updatedAt: new Date().toISOString(),
+  };
+  await writeJsonFile(runtimePaths.stateFile, nextState);
+  return nextState;
+}
+
+export async function saveState(state) {
+  return await withFileLock(runtimePaths.stateLockFile, async () => {
+    return await saveStateUnlocked(state);
+  });
+}
+
+export async function patchState(patchOrUpdater) {
+  return await withFileLock(runtimePaths.stateLockFile, async () => {
+    const current = await readJsonFile(runtimePaths.stateFile);
+    const normalizedCurrent =
+      current && typeof current === "object" && !Array.isArray(current)
+        ? normalizeStateSnapshot(current)
+        : buildDefaultState();
+    const patch =
+      typeof patchOrUpdater === "function"
+        ? await patchOrUpdater(normalizedCurrent)
+        : patchOrUpdater;
+    const normalizedPatch =
+      patch && typeof patch === "object" && !Array.isArray(patch) ? patch : {};
+
+    return await saveStateUnlocked({
+      ...normalizedCurrent,
+      ...normalizedPatch,
+      daemon: {
+        ...normalizedCurrent.daemon,
+        ...(normalizedPatch.daemon ?? {}),
+      },
+      backend: {
+        ...normalizedCurrent.backend,
+        ...(normalizedPatch.backend ?? {}),
+      },
+      directAccess: {
+        ...normalizedCurrent.directAccess,
+        ...(normalizedPatch.directAccess ?? {}),
+      },
+    });
+  });
+}
+
+export async function loadCredentials() {
+  await ensureRuntimeLayout();
+  const existing = await readJsonFile(runtimePaths.credentialsFile);
+  if (existing && typeof existing === "object" && !Array.isArray(existing)) {
+    return existing;
+  }
+  return {
+    linkId: null,
+    refreshToken: null,
+    refreshTokenExpiresAt: null,
+    accessToken: null,
+    accessTokenExpiresAt: null,
+  };
+}
+
+export async function saveCredentials(credentials) {
+  return await withFileLock(runtimePaths.credentialsLockFile, async () => {
+    await writeJsonFile(runtimePaths.credentialsFile, credentials);
+    return credentials;
+  });
+}
+
+export async function clearCredentials() {
+  return await saveCredentials({
+    linkId: null,
+    refreshToken: null,
+    refreshTokenExpiresAt: null,
+    accessToken: null,
+    accessTokenExpiresAt: null,
+  });
+}
+
+async function rotateLogFilesIfNeeded() {
+  let stats = null;
+  try {
+    stats = await fsp.stat(runtimePaths.logFile);
+  } catch (error) {
+    if (error && typeof error === "object" && error.code === "ENOENT") {
+      return;
+    }
+    throw error;
+  }
+
+  if (!stats || stats.size < LOG_ROTATION_MAX_BYTES) {
+    return;
+  }
+
+  const oldestBackupPath = `${runtimePaths.logFile}.${LOG_ROTATION_BACKUP_COUNT}`;
+  await fsp.unlink(oldestBackupPath).catch(() => undefined);
+
+  for (let index = LOG_ROTATION_BACKUP_COUNT - 1; index >= 1; index -= 1) {
+    const fromPath = `${runtimePaths.logFile}.${index}`;
+    const toPath = `${runtimePaths.logFile}.${index + 1}`;
+    await fsp.rename(fromPath, toPath).catch(() => undefined);
+  }
+
+  await fsp.rename(runtimePaths.logFile, `${runtimePaths.logFile}.1`).catch(() => undefined);
+}
+
+export async function appendLogLine(level, component, message, extra = undefined) {
+  await ensureRuntimeLayout();
+  const payload = {
+    ts: new Date().toISOString(),
+    level,
+    component,
+    message,
+    ...(extra && typeof extra === "object" ? extra : {}),
+  };
+  await withFileLock(runtimePaths.logLockFile, async () => {
+    await rotateLogFilesIfNeeded();
+    await fsp.appendFile(runtimePaths.logFile, `${JSON.stringify(payload)}\n`, "utf8");
+  });
+}
+
+export function logger(component) {
+  return {
+    info(message, extra) {
+      return appendLogLine("info", component, message, extra);
+    },
+    warn(message, extra) {
+      return appendLogLine("warn", component, message, extra);
+    },
+    error(message, extra) {
+      return appendLogLine("error", component, message, extra);
+    },
+  };
+}
+
+export function normalizeNonEmptyString(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const normalized = value.trim();
+  return normalized || null;
+}
+
+export function normalizeHttpsBaseUrl(value) {
+  const normalized = normalizeNonEmptyString(value);
+  if (!normalized) {
+    return null;
+  }
+
+  let parsed;
+  try {
+    parsed = new URL(normalized);
+  } catch {
+    return null;
+  }
+
+  if (parsed.protocol !== "https:") {
+    return null;
+  }
+
+  parsed.search = "";
+  parsed.hash = "";
+  return parsed.toString().replace(/\/+$/, "");
+}
+
+export function parseTimestamp(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  if (typeof value === "string" && value.trim()) {
+    const parsed = Date.parse(value);
+    if (!Number.isNaN(parsed)) {
+      return parsed;
+    }
+  }
+  return 0;
+}
+
+export function fileExists(filePath) {
+  return fs.existsSync(filePath);
+}

package/src/server-api.js

@@ -0,0 +1,135 @@
+import { normalizeNonEmptyString } from "./runtime.js";
+
+export class ServerApiError extends Error {
+  constructor(message, options = {}) {
+    super(message);
+    this.name = "ServerApiError";
+    this.status = Number.isInteger(options.status) ? options.status : 0;
+    this.errorCode = normalizeNonEmptyString(options.errorCode);
+    this.details = options.details;
+    this.payload = options.payload ?? null;
+  }
+}
+
+async function requestJson(url, init) {
+  let response;
+  try {
+    response = await fetch(url, init);
+  } catch (error) {
+    throw new ServerApiError(
+      error instanceof Error ? error.message : "Network request failed",
+      {
+        status: 0,
+      },
+    );
+  }
+
+  const text = await response.text();
+  let payload = null;
+  if (text) {
+    try {
+      payload = JSON.parse(text);
+    } catch {
+      payload = null;
+    }
+  }
+
+  if (!response.ok) {
+    const message =
+      payload &&
+      typeof payload === "object" &&
+      payload.error &&
+      typeof payload.error === "object" &&
+      typeof payload.error.message === "string"
+        ? payload.error.message
+        : `Request failed with HTTP ${response.status}`;
+    throw new ServerApiError(message, {
+      status: response.status,
+      errorCode:
+        payload &&
+        typeof payload === "object" &&
+        payload.error &&
+        typeof payload.error === "object"
+          ? normalizeNonEmptyString(payload.error.error_code)
+          : null,
+      details:
+        payload &&
+        typeof payload === "object" &&
+        payload.error &&
+        typeof payload.error === "object"
+          ? payload.error.details
+          : undefined,
+      payload,
+    });
+  }
+
+  return payload;
+}
+
+function joinApiUrl(baseUrl, pathname) {
+  return `${baseUrl.replace(/\/+$/, "")}${pathname}`;
+}
+
+export async function createPairingSession(params) {
+  return await requestJson(joinApiUrl(params.apiBaseUrl, "/api/v1/openclaw/link/pairing-sessions"), {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+    },
+    body: JSON.stringify({
+      installId: params.installId,
+      displayName: params.displayName,
+      hostname: params.hostname,
+      platform: params.platform,
+    }),
+  });
+}
+
+export async function bootstrapLink(params) {
+  return await requestJson(joinApiUrl(params.apiBaseUrl, "/api/v1/openclaw/link/bootstrap"), {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+    },
+    body: JSON.stringify({
+      pairingSessionId: params.pairingSessionId,
+      pairingToken: params.pairingToken,
+      installId: params.installId,
+      displayName: params.displayName,
+      hostname: params.hostname,
+      platform: params.platform,
+    }),
+  });
+}
+
+export async function createAccessToken(params) {
+  return await requestJson(joinApiUrl(params.apiBaseUrl, "/api/v1/openclaw/link/access-token"), {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+    },
+    body: JSON.stringify({
+      refreshToken: params.refreshToken,
+    }),
+  });
+}
+
+export async function updateLinkStatus(params) {
+  const accessToken = normalizeNonEmptyString(params.accessToken);
+  if (!accessToken) {
+    return null;
+  }
+
+  return await requestJson(joinApiUrl(params.apiBaseUrl, "/api/v1/openclaw/link/status"), {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+    },
+    body: JSON.stringify({
+      accessToken,
+      connectionStatus: params.connectionStatus,
+      backendUrl: params.backendUrl ?? undefined,
+      lastErrorMessage: params.lastErrorMessage ?? undefined,
+    }),
+  });
+}