@clawpilot-app/link 0.1.0

package/src/cli.js

@@ -0,0 +1,599 @@
+#!/usr/bin/env node
+import fsp from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import qrcode from "qrcode-terminal";
+import { LinkDaemon, isDaemonRunning, sendIpcRequest, spawnBackgroundDaemon, waitForDaemonReady } from "./daemon.js";
+import { createTranslator, resolveLanguage } from "./i18n.js";
+import { ServerApiError, createPairingSession, bootstrapLink } from "./server-api.js";
+import { LINK_DIRECT_PORT, listLanIpv4Addresses } from "./network.js";
+import {
+  encodeBase64UrlJson,
+  loadConfig,
+  loadCredentials,
+  loadState,
+  normalizeHttpsBaseUrl,
+  patchState,
+  runtimePaths,
+  saveCredentials,
+} from "./runtime.js";
+import { detectOpenClawBackend, installSkill } from "./openclaw.js";
+
+function parseFlags(argv) {
+  const flags = new Set();
+  const values = [];
+  for (const item of argv) {
+    if (item.startsWith("--")) {
+      flags.add(item);
+    } else {
+      values.push(item);
+    }
+  }
+  return {
+    flags,
+    values,
+  };
+}
+
+function printPairingQr(pairing, config) {
+  const directAddresses = listLanIpv4Addresses();
+  const payload = encodeBase64UrlJson({
+    v: 1,
+    typ: "join",
+    sid: pairing.pairingSessionId,
+    tok: pairing.pairingToken,
+    displayName: pairing.displayName,
+    hostname: pairing.hostname,
+    platform: pairing.platform,
+    directKey: config.directAccessKey,
+    directPort: LINK_DIRECT_PORT,
+    directAddresses,
+  });
+  console.log(`CLAWLINK:${payload}`);
+  qrcode.generate(`CLAWLINK:${payload}`, {
+    small: true,
+  });
+}
+
+function resolveBootstrapPollDelayMs(attempt) {
+  const schedule = [1_500, 2_000, 3_000, 5_000, 8_000, 12_000];
+  const baseDelayMs = schedule[Math.min(attempt, schedule.length - 1)];
+  const jitterMs = Math.floor(baseDelayMs * 0.15 * Math.random());
+  return baseDelayMs + jitterMs;
+}
+
+function printHumanStatus(translator, snapshot, daemonOnline) {
+  const state = snapshot.state ?? snapshot;
+  console.log(translator.t("statusTitle"));
+  console.log(
+    `- ${translator.t("statusLinkIdLabel")}: ${snapshot.credentials?.linkId ?? state.linkId ?? translator.t("statusNotPairedValue")}`,
+  );
+  console.log(`- ${translator.t("statusStateLabel")}: ${state.connectionStatus}`);
+  console.log(
+    `- ${translator.t("statusDaemonLabel")}: ${daemonOnline ? translator.t("statusDaemonOnlineValue") : translator.t("statusDaemonOfflineValue")}`,
+  );
+  console.log(
+    `- ${translator.t("statusOpenClawLabel")}: ${resolveBackendStatusMessage(translator, state.backend)}`,
+  );
+  console.log(
+    `- ${translator.t("statusLocalAccessLabel")}: ${resolveDirectAccessStatusMessage(
+      translator,
+      state.directAccess,
+      daemonOnline,
+    )}`,
+  );
+  if (state.lastErrorMessage) {
+    console.log(`- ${translator.t("statusLastErrorLabel")}: ${state.lastErrorMessage}`);
+  }
+  if (state.backend?.httpBaseUrl) {
+    console.log(`- ${translator.t("statusBackendUrlLabel")}: ${state.backend.httpBaseUrl}`);
+  }
+}
+
+function resolveBackendStatusMessage(translator, backend) {
+  if (!backend || typeof backend !== "object") {
+    return translator.t("statusUnknownValue");
+  }
+  if (!backend.detected) {
+    return translator.t("backendMissing");
+  }
+  if (!backend.supported) {
+    return translator.t("backendUnsupported");
+  }
+  if (typeof backend.port === "number" && Number.isFinite(backend.port)) {
+    return translator.t("backendReachableOnPort", { port: backend.port });
+  }
+  if (typeof backend.message === "string" && backend.message.trim()) {
+    return backend.message;
+  }
+  return translator.t("statusUnknownValue");
+}
+
+function resolveDirectAccessStatusMessage(translator, directAccess, daemonOnline) {
+  if (!daemonOnline) {
+    return translator.t("localAccessDaemonOffline");
+  }
+  if (!directAccess || typeof directAccess !== "object") {
+    return translator.t("localAccessUnavailable");
+  }
+
+  const port =
+    typeof directAccess.port === "number" && Number.isFinite(directAccess.port)
+      ? Math.trunc(directAccess.port)
+      : LINK_DIRECT_PORT;
+  const reason =
+    typeof directAccess.reason === "string" && directAccess.reason.trim()
+      ? directAccess.reason.trim()
+      : null;
+  const message =
+    typeof directAccess.message === "string" && directAccess.message.trim()
+      ? directAccess.message.trim()
+      : null;
+
+  if (directAccess.status === "listening") {
+    return translator.t("localAccessReadyOnPort", { port });
+  }
+  if (reason === "port_in_use") {
+    return translator.t("localAccessPortInUse", { port });
+  }
+  if (reason === "permission_denied") {
+    return translator.t("localAccessPermissionDenied", { port });
+  }
+  return message ?? translator.t("localAccessUnavailable");
+}
+
+async function printDirectAccessWarningIfNeeded(translator) {
+  let snapshot = null;
+  for (let attempt = 0; attempt < 6; attempt += 1) {
+    try {
+      snapshot = await sendIpcRequest("status.get", {});
+    } catch {
+      return;
+    }
+
+    if (snapshot?.state?.directAccess?.status !== "unknown") {
+      break;
+    }
+
+    await new Promise((resolve) => setTimeout(resolve, 200));
+  }
+
+  if (snapshot?.state?.directAccess?.status === "listening") {
+    return;
+  }
+
+  console.warn(translator.t("localAccessNeedsAttention"));
+  console.warn(
+    resolveDirectAccessStatusMessage(translator, snapshot?.state?.directAccess, true),
+  );
+}
+
+async function loadRuntimeSnapshot() {
+  const [config, state, credentials] = await Promise.all([
+    loadConfig(),
+    loadState(),
+    loadCredentials(),
+  ]);
+  const t = createTranslator(resolveLanguage(config.language));
+  return { config, state, credentials, t };
+}
+
+function getValidatedRelayBaseUrl(translator, config) {
+  const relayBaseUrl = normalizeHttpsBaseUrl(config.relayBaseUrl);
+  if (!relayBaseUrl) {
+    throw new Error(
+      translator.t("relayConfigInsecure", {
+        configFile: runtimePaths.configFile,
+      }),
+    );
+  }
+  return relayBaseUrl;
+}
+
+async function commandPair() {
+  const { config, credentials, t } = await loadRuntimeSnapshot();
+  if (credentials.linkId) {
+    await commandQr();
+    return;
+  }
+
+  const pairing = await createPairingSession({
+    apiBaseUrl: config.apiBaseUrl,
+    installId: config.installId,
+    displayName: config.displayName,
+    hostname: os.hostname(),
+    platform: process.platform,
+  });
+
+  await patchState({
+    connectionStatus: "pairing",
+    pairingSession: {
+      pairingSessionId: pairing.pairingSessionId,
+      expiresAt: pairing.expiresAt,
+      shortCode: pairing.shortCode,
+      claimMode: pairing.claimMode,
+    },
+  });
+
+  console.log(t.t("pairingCreated"));
+  console.log(`${t.t("scanPrompt")}`);
+  printPairingQr(pairing, config);
+  console.log(`${t.t("manualCode")}: ${pairing.shortCode}`);
+  console.log(t.t("waitingForScan"));
+
+  const expiresAtMs = Date.parse(pairing.expiresAt);
+  let pollAttempt = 0;
+  while (Date.now() < expiresAtMs) {
+    let bootstrap;
+    try {
+      bootstrap = await bootstrapLink({
+        apiBaseUrl: config.apiBaseUrl,
+        pairingSessionId: pairing.pairingSessionId,
+        pairingToken: pairing.pairingToken,
+        installId: config.installId,
+        displayName: config.displayName,
+        hostname: os.hostname(),
+        platform: process.platform,
+      });
+    } catch (error) {
+      if (
+        error instanceof ServerApiError &&
+        (error.status === 401 || error.status === 403 || error.status === 410)
+      ) {
+        console.error(error.message);
+        process.exitCode = 1;
+        return;
+      }
+      pollAttempt += 1;
+      const remainingMs = expiresAtMs - Date.now();
+      if (remainingMs <= 0) {
+        break;
+      }
+      await new Promise((resolve) =>
+        setTimeout(resolve, Math.min(resolveBootstrapPollDelayMs(pollAttempt), remainingMs)),
+      );
+      continue;
+    }
+
+    if (bootstrap.ready) {
+      await saveCredentials({
+        linkId: bootstrap.link.linkId,
+        refreshToken: bootstrap.refreshToken,
+        refreshTokenExpiresAt: bootstrap.refreshTokenExpiresAt,
+        accessToken: bootstrap.accessToken?.token ?? null,
+        accessTokenExpiresAt: bootstrap.accessToken?.expiresAt ?? null,
+      });
+      await patchState({
+        linkId: bootstrap.link.linkId,
+        pairingSession: null,
+        connectionStatus: "paired",
+        lastErrorMessage: null,
+      });
+      await installSkill(resolveLanguage(config.language));
+      console.log(t.t("pairingSuccess"));
+      if (config.autoStartAfterPair) {
+        config.relayBaseUrl = getValidatedRelayBaseUrl(t, config);
+        console.log(t.t("startDaemonAfterPair"));
+        spawnBackgroundDaemon();
+        const ready = await waitForDaemonReady();
+        if (!ready) {
+          throw new Error(t.t("startDaemonFailed"));
+        }
+        await printDirectAccessWarningIfNeeded(t);
+      }
+      return;
+    }
+
+    pollAttempt += 1;
+    const remainingMs = expiresAtMs - Date.now();
+    if (remainingMs <= 0) {
+      break;
+    }
+    await new Promise((resolve) =>
+      setTimeout(resolve, Math.min(resolveBootstrapPollDelayMs(pollAttempt), remainingMs)),
+    );
+  }
+
+  console.error(t.t("pairingExpired"));
+  process.exitCode = 1;
+}
+
+async function commandQr() {
+  const { config, credentials, t } = await loadRuntimeSnapshot();
+  if (!credentials.linkId) {
+    console.error(t.t("qrNeedsPair"));
+    process.exitCode = 1;
+    return;
+  }
+
+  const pairing = await createPairingSession({
+    apiBaseUrl: config.apiBaseUrl,
+    installId: config.installId,
+    displayName: config.displayName,
+    hostname: os.hostname(),
+    platform: process.platform,
+  });
+
+  await patchState({
+    pairingSession: {
+      pairingSessionId: pairing.pairingSessionId,
+      expiresAt: pairing.expiresAt,
+      shortCode: pairing.shortCode,
+      claimMode: pairing.claimMode,
+    },
+  });
+
+  console.log(t.t("qrJoinReady"));
+  console.log(`${t.t("scanPrompt")}`);
+  printPairingQr(pairing, config);
+  console.log(`${t.t("manualCode")}: ${pairing.shortCode}`);
+}
+
+async function commandConnect(flags) {
+  const { config, credentials, t } = await loadRuntimeSnapshot();
+  if (!credentials.linkId) {
+    console.error(t.t("notPaired"));
+    process.exitCode = 1;
+    return;
+  }
+
+  if (flags.has("--foreground")) {
+    config.relayBaseUrl = getValidatedRelayBaseUrl(t, config);
+    console.log(t.t("connectForeground"));
+    const state = await loadState();
+    const daemon = new LinkDaemon(config, state, credentials);
+    process.on("SIGINT", () => {
+      void daemon.stop();
+    });
+    process.on("SIGTERM", () => {
+      void daemon.stop();
+    });
+    await daemon.start();
+    return;
+  }
+
+  if (await isDaemonRunning()) {
+    await sendIpcRequest("daemon.reconnect", {});
+    console.log(t.t("daemonAlreadyRunning"));
+    await printDirectAccessWarningIfNeeded(t);
+    return;
+  }
+
+  getValidatedRelayBaseUrl(t, config);
+  spawnBackgroundDaemon();
+  const ready = await waitForDaemonReady();
+  if (!ready) {
+    throw new Error(t.t("startDaemonFailed"));
+  }
+  console.log(t.t("connectBackground"));
+  await printDirectAccessWarningIfNeeded(t);
+}
+
+async function commandStatus(flags) {
+  const { credentials, state, t } = await loadRuntimeSnapshot();
+  let daemonOnline = false;
+  let snapshot = {
+    state,
+    credentials,
+  };
+
+  try {
+    snapshot = await sendIpcRequest("status.get", {});
+    daemonOnline = true;
+  } catch {
+    daemonOnline = false;
+  }
+
+  if (flags.has("--json")) {
+    console.log(JSON.stringify({ ...snapshot, daemonOnline }, null, 2));
+    return;
+  }
+
+  printHumanStatus(t, snapshot, daemonOnline);
+}
+
+async function commandDoctor(flags) {
+  const { config, state, credentials, t } = await loadRuntimeSnapshot();
+  const backend = await detectOpenClawBackend();
+  const daemonOnline = await isDaemonRunning();
+  let liveState = state;
+  if (daemonOnline) {
+    try {
+      const snapshot = await sendIpcRequest("status.get", {});
+      if (snapshot?.state && typeof snapshot.state === "object") {
+        liveState = snapshot.state;
+      }
+    } catch {
+      // Ignore IPC failures and fall back to the last persisted state.
+    }
+  }
+  const relayBaseUrl = normalizeHttpsBaseUrl(config.relayBaseUrl);
+  const relayHealth = relayBaseUrl
+    ? await fetch(`${relayBaseUrl}/healthz`)
+        .then((response) => response.ok)
+        .catch(() => false)
+    : false;
+  const apiHealth = await fetch(`${config.apiBaseUrl.replace(/\/+$/, "")}/healthz`)
+    .then((response) => response.ok)
+    .catch(() => false);
+  const skillPath = path.join(path.dirname(process.env.OPENCLAW_CONFIG_PATH || path.join(os.homedir(), ".openclaw", "openclaw.json")), "skills", "clawpilot-link", "SKILL.md");
+  const skillInstalled = await fsp.access(skillPath).then(() => true).catch(() => false);
+
+  const checks = [
+    {
+      key: "paired",
+      ok: Boolean(credentials.linkId),
+      message: Boolean(credentials.linkId) ? t.t("pairedOk") : t.t("notPaired"),
+    },
+    {
+      key: "daemon",
+      ok: daemonOnline,
+      message: daemonOnline ? t.t("daemonRunning") : t.t("daemonNotRunning"),
+    },
+    {
+      key: "relay-config",
+      ok: Boolean(relayBaseUrl),
+      message: relayBaseUrl
+        ? t.t("relayConfigSecure")
+        : t.t("relayConfigInsecure", {
+            configFile: runtimePaths.configFile,
+          }),
+    },
+    {
+      key: "backend",
+      ok: backend.detected && backend.supported,
+      message: resolveBackendStatusMessage(t, backend),
+    },
+    {
+      key: "local-access",
+      ok: daemonOnline && liveState.directAccess?.status === "listening",
+      message: resolveDirectAccessStatusMessage(t, liveState.directAccess, daemonOnline),
+    },
+    {
+      key: "relay",
+      ok: relayBaseUrl ? relayHealth : false,
+      message: relayBaseUrl
+        ? relayHealth
+          ? t.t("relayReachable")
+          : t.t("relayUnreachable")
+        : t.t("relayCheckSkipped"),
+    },
+    {
+      key: "api",
+      ok: apiHealth,
+      message: apiHealth ? t.t("apiReachable") : t.t("apiUnreachable"),
+    },
+    {
+      key: "skill",
+      ok: skillInstalled,
+      message: skillInstalled ? t.t("skillInstalled") : t.t("skillMissing"),
+    },
+  ];
+
+  if (flags.has("--json")) {
+    console.log(
+      JSON.stringify(
+        {
+          ok: checks.every((item) => item.ok),
+          checks,
+          backend,
+          daemonOnline,
+          state: liveState,
+        },
+        null,
+        2,
+      ),
+    );
+    return;
+  }
+
+  for (const check of checks) {
+    console.log(`- [${check.ok ? "OK" : "NO"}] ${check.message}`);
+  }
+  console.log(checks.every((item) => item.ok) ? t.t("doctorSummaryOk") : t.t("doctorSummaryFix"));
+}
+
+async function commandRestart() {
+  const { config, t } = await loadRuntimeSnapshot();
+  getValidatedRelayBaseUrl(t, config);
+  try {
+    await sendIpcRequest("daemon.shutdown", {}, 1_500);
+  } catch {
+    // Ignore shutdown failures and try a fresh start anyway.
+  }
+  spawnBackgroundDaemon();
+  const ready = await waitForDaemonReady();
+  if (!ready) {
+    throw new Error(t.t("restartFailed"));
+  }
+  console.log(t.t("restartDone"));
+  await printDirectAccessWarningIfNeeded(t);
+}
+
+async function commandUnpair(flags) {
+  const { t } = await loadRuntimeSnapshot();
+  if (!flags.has("--yes")) {
+    console.error(t.t("unpairConfirm"));
+    process.exitCode = 1;
+    return;
+  }
+  try {
+    await sendIpcRequest("daemon.shutdown", {}, 1_500);
+  } catch {
+    // Ignore shutdown failures.
+  }
+  await saveCredentials({
+    linkId: null,
+    refreshToken: null,
+    refreshTokenExpiresAt: null,
+    accessToken: null,
+    accessTokenExpiresAt: null,
+  });
+  await patchState({
+    linkId: null,
+    connectionStatus: "new",
+    pairingSession: null,
+  });
+  console.log(t.t("daemonStopped"));
+}
+
+async function commandDaemon() {
+  const [config, state, credentials] = await Promise.all([
+    loadConfig(),
+    loadState(),
+    loadCredentials(),
+  ]);
+  const t = createTranslator(resolveLanguage(config.language));
+  config.relayBaseUrl = getValidatedRelayBaseUrl(t, config);
+  const daemon = new LinkDaemon(config, state, credentials);
+  process.on("SIGINT", () => {
+    void daemon.stop();
+  });
+  process.on("SIGTERM", () => {
+    void daemon.stop();
+  });
+  await daemon.start();
+}
+
+async function main() {
+  const [, , rawCommand, ...restArgs] = process.argv;
+  const command = rawCommand ?? "status";
+  const { flags } = parseFlags(restArgs);
+  const { t } = await loadRuntimeSnapshot();
+
+  switch (command) {
+    case "pair":
+      await commandPair();
+      return;
+    case "qr":
+      await commandQr();
+      return;
+    case "connect":
+      await commandConnect(flags);
+      return;
+    case "status":
+      await commandStatus(flags);
+      return;
+    case "doctor":
+      await commandDoctor(flags);
+      return;
+    case "restart":
+      await commandRestart();
+      return;
+    case "unpair":
+      await commandUnpair(flags);
+      return;
+    case "daemon":
+      await commandDaemon();
+      return;
+    default:
+      console.error(`${t.t("unknownCommand")}: ${command}`);
+      console.error(t.t("availableCommands"));
+      process.exitCode = 1;
+  }
+}
+
+main().catch((error) => {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exitCode = 1;
+});

package/src/constants.js

@@ -0,0 +1 @@
+export const LINK_VERSION = "0.1.0";