nebulon-escrow-cli 0.1.0

package/src/commands/invites.js

@@ -0,0 +1,345 @@
+const { prompt } = require("enquirer");
+const { loadConfig } = require("../config");
+const { ensureHostedSession } = require("../session");
+const {
+  getInvites,
+  acceptInviteById,
+  declineInvite,
+  setContractKey,
+  getContractKeys,
+  getContract,
+} = require("../hosted");
+const { ensureContractKeypair } = require("../privacy");
+const { successMessage } = require("../ui");
+
+const formatCreatedAt = (value) => {
+  if (!value) {
+    return "n/a";
+  }
+  const date = new Date(value * 1000);
+  if (Number.isNaN(date.getTime())) {
+    return "n/a";
+  }
+  return date.toISOString().replace("T", " ").slice(0, 19);
+};
+
+const formatHandle = (handle, wallet) => {
+  if (handle) {
+    return `@${handle}`;
+  }
+  if (wallet) {
+    return `${wallet.slice(0, 4)}...${wallet.slice(-4)}`;
+  }
+  return "n/a";
+};
+
+const resolveOptions = (options) => {
+  if (!options) {
+    return {};
+  }
+  if (typeof options.opts === "function") {
+    return options.opts();
+  }
+  return options;
+};
+
+const printInvites = (invites, options = {}) => {
+  const resolved = resolveOptions(options);
+  const label = resolved.showAll ? "Nebulon Invites (All)" : "Nebulon Invites";
+  console.log(label);
+  if (!invites.length) {
+    console.log("No invites found.");
+    return;
+  }
+  console.log("#  Type      Status    Role        Contract ID                           From          Date");
+  invites.forEach((invite, index) => {
+    const row = [
+      String(index + 1).padEnd(3, " "),
+      String(invite.type).padEnd(9, " "),
+      String(invite.status).padEnd(9, " "),
+      String(invite.role).padEnd(11, " "),
+      String(invite.contractId).padEnd(36, " "),
+      String(invite.counterparty || "n/a").padEnd(12, " "),
+      invite.createdAt,
+    ];
+    console.log(row.join(" "));
+  });
+};
+
+const runInviteList = async (filter, options = {}) => {
+  const config = loadConfig();
+  if (config.mode !== "hosted") {
+    console.error("Direct mode invites are not implemented yet.");
+    process.exit(1);
+  }
+  try {
+    await ensureHostedSession(config, { quiet: true, requireHandle: true });
+  } catch (error) {
+    console.error(error.message);
+    process.exit(1);
+  }
+
+  const result = await getInvites(config.backendUrl, config.auth.token);
+  const sent = Array.isArray(result.sent) ? result.sent : [];
+  const received = Array.isArray(result.received) ? result.received : [];
+  const resolved = resolveOptions(options);
+  let showAll = Boolean(resolved.showAll);
+  if (!showAll && Array.isArray(process.argv)) {
+    showAll = process.argv.includes("--show-all");
+  }
+  if (typeof filter === "string" && filter.trim().toLowerCase() === "--show-all") {
+    showAll = true;
+    filter = null;
+  }
+  const pendingOnly = !showAll;
+  const sentFiltered = pendingOnly
+    ? sent.filter((invite) => invite.status === "pending")
+    : sent;
+  const receivedFiltered = pendingOnly
+    ? received.filter((invite) => invite.status === "pending")
+    : received;
+
+  const sentRows = sentFiltered.map((invite) => ({
+    type: "sent",
+    status: invite.status,
+    role: invite.invitee_role || "n/a",
+    contractId: invite.contract_id,
+    counterparty: invite.invitee_handle
+      ? `@${invite.invitee_handle}`
+      : invite.invitee_wallet
+        ? formatHandle(null, invite.invitee_wallet)
+        : "link",
+    createdAt: formatCreatedAt(invite.created_at),
+  }));
+
+  const receivedRows = receivedFiltered.map((invite) => ({
+    type: "received",
+    status: invite.status,
+    role: invite.invitee_role || "n/a",
+    contractId: invite.contract_id,
+    counterparty: formatHandle(invite.issuer_handle, invite.issuer_wallet),
+    createdAt: formatCreatedAt(invite.created_at),
+  }));
+
+  let rows = [...receivedRows, ...sentRows];
+  if (filter === "sent") {
+    rows = sentRows;
+  } else if (filter === "received") {
+    rows = receivedRows;
+  }
+
+  printInvites(rows, options);
+  return { sent: sentFiltered, received: receivedFiltered, sentRows, receivedRows };
+};
+
+const resolveInviteSelection = (received, target) => {
+  const matchByIndex = Number.parseInt(target, 10);
+  if (!Number.isNaN(matchByIndex)) {
+    const idx = matchByIndex - 1;
+    if (idx >= 0 && idx < received.length) {
+      return received[idx];
+    }
+    return null;
+  }
+  return received.find(
+    (invite) =>
+      invite.contract_id === target || invite.id === target
+  );
+};
+
+const resolveInviteSelectionAll = (received, sent, target) => {
+  const combined = [...received, ...sent];
+  const matchByIndex = Number.parseInt(target, 10);
+  if (!Number.isNaN(matchByIndex)) {
+    const idx = matchByIndex - 1;
+    if (idx >= 0 && idx < combined.length) {
+      return combined[idx];
+    }
+    return null;
+  }
+  return combined.find(
+    (invite) =>
+      invite.contract_id === target || invite.id === target
+  );
+};
+
+const renderInviteDetails = (invite) => {
+  console.log("Invite details");
+  console.log(`Contract ID: ${invite.contract_id}`);
+  console.log(
+    `From: ${formatHandle(invite.issuer_handle, invite.issuer_wallet)}`
+  );
+  console.log(`Created: ${formatCreatedAt(invite.created_at)}`);
+  console.log("");
+};
+
+const renderInviteStatus = async (config, invite) => {
+  const detail = await getContract(
+    config.backendUrl,
+    config.auth.token,
+    invite.contract_id
+  );
+  const contract = detail.contract;
+  if (!contract) {
+    console.error("Contract not found.");
+    process.exit(1);
+  }
+  const customer = formatHandle(contract.client_handle, contract.client_wallet);
+  const provider = formatHandle(
+    contract.contractor_handle,
+    contract.contractor_wallet
+  );
+  const selfWallet = config.auth.wallet;
+  const role =
+    contract.client_wallet === selfWallet
+      ? "client"
+      : contract.contractor_wallet === selfWallet
+        ? "contractor"
+        : "other";
+  console.log(`Invite ID: ${invite.id}`);
+  console.log(`Customer: ${customer}${contract.client_wallet === selfWallet ? " (YOU)" : ""}`);
+  console.log(
+    `Service Provider: ${provider}${contract.contractor_wallet === selfWallet ? " (YOU)" : ""}`
+  );
+  console.log(`Role: ${role}`);
+  console.log("");
+  console.log(`Current status: ${invite.status}`);
+};
+
+const runInviteAction = async (target, action) => {
+  const config = loadConfig();
+  if (config.mode !== "hosted") {
+    console.error("Direct mode invites are not implemented yet.");
+    process.exit(1);
+  }
+  try {
+    await ensureHostedSession(config, { quiet: true, requireHandle: true });
+  } catch (error) {
+    console.error(error.message);
+    process.exit(1);
+  }
+
+  if (!target) {
+    console.log("Usage: nebulon invite <index|contractId> [accept|deny]");
+    return;
+  }
+
+  const result = await getInvites(config.backendUrl, config.auth.token);
+  const receivedAll = Array.isArray(result.received) ? result.received : [];
+  const sentAll = Array.isArray(result.sent) ? result.sent : [];
+  const receivedPending = receivedAll.filter((invite) => invite.status === "pending");
+  const actionKey = (action || "").toLowerCase();
+  const invite =
+    actionKey === "status"
+      ? resolveInviteSelectionAll(receivedAll, sentAll, target.trim())
+      : resolveInviteSelection(receivedPending, target.trim());
+  if (!invite) {
+    console.error("Invite not found.");
+    process.exit(1);
+  }
+
+  if (actionKey === "status") {
+    await renderInviteStatus(config, invite);
+    return;
+  }
+
+  renderInviteDetails(invite);
+
+  const normalizeDecision = (value) => {
+    if (!value) {
+      return null;
+    }
+    const lowered = value.trim().toLowerCase();
+    if (["accept", "a", "yes", "y"].includes(lowered)) {
+      return "accept";
+    }
+    if (["deny", "decline", "d", "no", "n"].includes(lowered)) {
+      return "deny";
+    }
+    return null;
+  };
+
+  let decision = normalizeDecision(action);
+  if (!decision) {
+    const answer = await prompt({
+      type: "input",
+      name: "decision",
+      message: "Do you want to accept this invite? (yes/no)",
+      initial: "yes",
+      validate: (value) =>
+        normalizeDecision(value) ? true : "Type yes or no.",
+    });
+    decision = normalizeDecision(answer.decision);
+  }
+
+  if (!decision) {
+    console.log("Usage: nebulon invite <index|contractId> [accept|deny]");
+    return;
+  }
+
+  try {
+    if (decision === "accept") {
+      const accepted = await acceptInviteById(
+          config.backendUrl,
+          config.auth.token,
+          { inviteId: invite.id }
+        );
+        console.log("Invite accepted.");
+        console.log(`Contract ID: ${accepted.contractId}`);
+        console.log(`Status: ${accepted.status}`);
+        // Fetch complete contract data to ensure we have escrow_pda
+        const contractDetail = await getContract(
+          config.backendUrl,
+          config.auth.token,
+          accepted.contractId
+        );
+      console.log("Setting up privacy keys...");
+      try {
+        const keypair = ensureContractKeypair(config, accepted.contractId);
+        await setContractKey(
+          config.backendUrl,
+          config.auth.token,
+          accepted.contractId,
+          keypair.publicKey
+        );
+        const keys = await getContractKeys(
+          config.backendUrl,
+          config.auth.token,
+          accepted.contractId
+        );
+        const count = Array.isArray(keys.keys) ? keys.keys.length : 0;
+        if (count > 1) {
+          console.log("Privacy key exchange complete.");
+        } else {
+          console.log("Privacy key registered. Awaiting counterparty.");
+        }
+      } catch (error) {
+        console.log("Privacy key setup pending. Try again later.");
+      }
+      successMessage("Invite accepted.");
+      return;
+    }
+
+    const declined = await declineInvite(
+      config.backendUrl,
+      config.auth.token,
+      { inviteId: invite.id }
+    );
+    console.log("Invite declined.");
+    console.log(`Contract ID: ${declined.contractId}`);
+    console.log(`Status: ${declined.status}`);
+    successMessage("Invite declined.");
+  } catch (error) {
+    if (error && error.message === "Not Found") {
+      console.error("Invite action failed: backend missing invite action routes.");
+      console.error("Restart the backend after updating to the latest code.");
+      process.exit(1);
+    }
+    throw error;
+  }
+};
+
+module.exports = {
+  runInviteList,
+  runInviteAction,
+};

package/src/commands/login.js

@@ -0,0 +1,320 @@
+const { prompt } = require("enquirer");
+const chalk = require("chalk");
+const { loadConfig, saveConfig } = require("../config");
+const { successMessage } = require("../ui");
+const { loadWalletKeypair } = require("../wallets");
+const { getChallenge, signChallenge, verify, me, checkHandle, updateHandle } = require("../hosted");
+
+const HANDLE_REGEX = /^[a-z0-9._-]+$/;
+const PFP_CHOICES = [
+  { name: "1 - galaxy", message: "1 - galaxy", value: "1" },
+  { name: "2 - alien", message: "2 - alien", value: "2" },
+  { name: "3 - star", message: "3 - star", value: "3" },
+  { name: "4 - moon", message: "4 - moon", value: "4" },
+  { name: "5 - spaceship", message: "5 - spaceship", value: "5" },
+  { name: "6 - glyph", message: "6 - glyph", value: "6" },
+  { name: "7 - saturn", message: "7 - saturn", value: "7" },
+  { name: "8 - singularity", message: "8 - singularity", value: "8" },
+];
+
+const isPromptCancel = (error) => {
+  if (!error) {
+    return true;
+  }
+  if (typeof error === "string") {
+    return error.trim() === "";
+  }
+  const message = (error.message || "").toLowerCase();
+  return (
+    message.includes("cancel") ||
+    message.includes("aborted") ||
+    message.includes("terminated")
+  );
+};
+
+const nowSeconds = () => Math.floor(Date.now() / 1000);
+
+const normalizeHandle = (value) =>
+  value.trim().toLowerCase().replace(/^@/, "");
+
+const validateHandleLocally = (handle) => {
+  if (!handle) {
+    return { ok: false, reason: "missing" };
+  }
+  if (handle.length < 4 || handle.length > 16) {
+    return { ok: false, reason: "length" };
+  }
+  if (!HANDLE_REGEX.test(handle)) {
+    return { ok: false, reason: "characters" };
+  }
+  if (handle.startsWith(".") || handle.endsWith(".")) {
+    return { ok: false, reason: "dots" };
+  }
+  if (handle.includes("..")) {
+    return { ok: false, reason: "dots" };
+  }
+  return { ok: true, value: handle };
+};
+
+const handleReasonMessage = (reason) => {
+  switch (reason) {
+    case "missing":
+      return "ID is required.";
+    case "length":
+      return "Must be 4-16 characters.";
+    case "characters":
+      return "Only letters, numbers, dots, underscores, and hyphens.";
+    case "dots":
+      return "Cannot start/end with dots or have consecutive dots.";
+    case "taken":
+      return "This ID is already taken.";
+    case "reserved":
+      return "This ID is reserved.";
+    case "error":
+      return "Error checking availability.";
+    default:
+      return "Invalid Nebulon ID.";
+  }
+};
+
+const ensureAuthState = (config) => {
+  if (!config.auth) {
+    config.auth = {
+      token: null,
+      wallet: null,
+      handle: null,
+      role: null,
+      lastAuthAt: null,
+    };
+  }
+};
+
+const clearAuthState = (config) => {
+  config.auth = {
+    token: null,
+    wallet: null,
+    handle: null,
+    role: null,
+    lastAuthAt: null,
+  };
+};
+
+const validateHandleAvailability = async (baseUrl, handle) => {
+  const local = validateHandleLocally(handle);
+  if (!local.ok) {
+    return { ok: false, reason: local.reason };
+  }
+  const remote = await checkHandle(baseUrl, handle);
+  if (!remote.available) {
+    return { ok: false, reason: remote.reason || "taken" };
+  }
+  return { ok: true };
+};
+
+const promptForHandle = async (baseUrl) => {
+  const answer = await prompt({
+    type: "input",
+    name: "handle",
+    message: "Nebulon ID (optional)",
+    hint: "Leave blank to auto-generate",
+    validate: async (value) => {
+      const normalized = normalizeHandle(value || "");
+      if (!normalized) {
+        return true;
+      }
+      try {
+        const validation = await validateHandleAvailability(baseUrl, normalized);
+        if (!validation.ok) {
+          return handleReasonMessage(validation.reason);
+        }
+      } catch (error) {
+        return handleReasonMessage("error");
+      }
+      return true;
+    },
+  });
+  const normalized = normalizeHandle(answer.handle || "");
+  return normalized || null;
+};
+
+const promptForPfp = async () => {
+  const answer = await prompt({
+    type: "select",
+    name: "pfp",
+    message: "Select profile picture",
+    choices: PFP_CHOICES,
+  });
+  if (!answer.pfp) {
+    return null;
+  }
+  return answer.pfp.endsWith(".png") ? answer.pfp : `${answer.pfp}.png`;
+};
+
+const dumpActiveHandles = () => {
+  if (typeof process._getActiveHandles !== "function") {
+    return;
+  }
+  const handles = process._getActiveHandles();
+  const requests =
+    typeof process._getActiveRequests === "function"
+      ? process._getActiveRequests()
+      : [];
+
+  const summarize = (item) => {
+    if (!item) {
+      return "unknown";
+    }
+    if (item.constructor && item.constructor.name) {
+      return item.constructor.name;
+    }
+    return typeof item;
+  };
+
+  console.log("Debug: active handles:", handles.map(summarize).join(", "));
+  if (requests.length) {
+    console.log(
+      "Debug: active requests:",
+      requests.map(summarize).join(", ")
+    );
+  }
+  console.log(
+    `Debug: stdin paused=${process.stdin.isPaused()} readable=${process.stdin.readable}`
+  );
+};
+
+const finalizeLogin = (debug, exitCode = 0) => {
+  if (debug) {
+    dumpActiveHandles();
+  }
+  if (process.stdin.isTTY) {
+    try {
+      process.stdin.setRawMode(false);
+    } catch (error) {
+      // ignore
+    }
+    process.stdin.pause();
+  }
+  process.exit(exitCode);
+};
+
+const runLogin = async (options = {}) => {
+  const debug = Boolean(options.debug);
+  const config = loadConfig();
+  if (config.mode !== "hosted") {
+    console.log("Direct mode does not use hosted login.");
+    return;
+  }
+  if (!config.activeWallet) {
+    console.error("No active wallet. Run: nebulon init");
+    process.exit(1);
+  }
+  ensureAuthState(config);
+  const keypair = loadWalletKeypair(config, config.activeWallet);
+  const wallet = keypair.publicKey.toBase58();
+
+  try {
+    if (config.auth.token) {
+      try {
+        const profile = await me(config.backendUrl, config.auth.token);
+        config.auth.wallet = profile.wallet;
+        config.auth.handle = profile.nebulonId || profile.handle || null;
+        config.auth.role = profile.role || null;
+      } catch (error) {
+        clearAuthState(config);
+      }
+    }
+
+    console.log("Requesting challenge...");
+    const challenge = await getChallenge(config.backendUrl, wallet);
+    if (debug) {
+      console.log("Debug: challenge nonce", challenge.nonce);
+    }
+
+    console.log("Signing challenge...");
+    const signature = signChallenge(keypair, challenge.message);
+    if (debug) {
+      console.log("Debug: signature length", signature.length);
+    }
+    const result = await verify(config.backendUrl, {
+      wallet,
+      nonce: challenge.nonce,
+      signature,
+    });
+    if (debug) {
+      console.log("Debug: verify user", result.user);
+    }
+
+    config.auth.token = result.token;
+    config.auth.wallet = result.user.wallet;
+    config.auth.handle = result.user.handle || null;
+    config.auth.role = result.user.role || null;
+    config.auth.lastAuthAt = nowSeconds();
+    saveConfig(config);
+
+    if (!config.auth.handle) {
+      console.log("First-time setup detected.");
+      console.log(
+        "Choose a Nebulon ID (leave blank to auto-generate) and a profile picture."
+      );
+      let desiredHandle = options.handle ? normalizeHandle(options.handle) : null;
+      if (options.handle) {
+        const validation = await validateHandleAvailability(
+          config.backendUrl,
+          desiredHandle
+        );
+        if (!validation.ok) {
+          console.error(`Handle invalid: ${handleReasonMessage(validation.reason)}`);
+          process.exit(1);
+        }
+      } else {
+        try {
+          desiredHandle = await promptForHandle(config.backendUrl);
+        } catch (error) {
+          if (isPromptCancel(error)) {
+            console.log("Login canceled - no changes applied.");
+            return;
+          }
+          throw error;
+        }
+      }
+
+      let pfpChoice = null;
+      try {
+        pfpChoice = await promptForPfp();
+      } catch (error) {
+        if (isPromptCancel(error)) {
+          console.log("Login canceled - no changes applied.");
+          return;
+        }
+        throw error;
+      }
+
+      if (debug) {
+        console.log("Debug: handle update payload", {
+          handle: desiredHandle || null,
+          pfp: pfpChoice || null,
+        });
+      }
+      const update = await updateHandle(
+        config.backendUrl,
+        config.auth.token,
+        desiredHandle,
+        pfpChoice
+      );
+      if (debug) {
+        console.log("Debug: handle update response", update);
+      }
+      config.auth.handle = update.handle || desiredHandle;
+      saveConfig(config);
+    }
+
+    successMessage("Login successful.");
+    finalizeLogin(debug, 0);
+  } catch (error) {
+    throw new Error(error && error.message ? error.message : "Login failed.");
+  }
+};
+
+module.exports = {
+  runLogin,
+};

package/src/commands/logout.js

@@ -0,0 +1,22 @@
+const { loadConfig, saveConfig } = require("../config");
+
+const runLogout = async () => {
+  const config = loadConfig();
+  if (!config.auth) {
+    console.log("Already logged out.");
+    return;
+  }
+  config.auth = {
+    token: null,
+    wallet: null,
+    handle: null,
+    role: null,
+    lastAuthAt: null,
+  };
+  saveConfig(config);
+  console.log("Logged out.");
+};
+
+module.exports = {
+  runLogout,
+};