@ai-digital-factory/lmt-web-cli 0.1.4 → 0.1.5

package/dist/interactive-main-ETL5PV4H.js

@@ -0,0 +1,308 @@
+import {
+  parseInteractiveArguments,
+  requestSession,
+  startSession
+} from "./chunk-G5T7UDIK.js";
+
+// src/interactive-main.ts
+import { createElement } from "react";
+import { render } from "ink";
+
+// src/interactive-app.tsx
+import { Box, Text, useApp, useInput } from "ink";
+import { useRef, useState } from "react";
+
+// src/interactive-login.ts
+var RESTORE_DEADLINE_MS = 3e4;
+var RESTORE_POLL_MS = 500;
+var UNCERTAIN_MESSAGE = "The browser could not confirm the result. Check the page with `lmt-web inspect` before trying again; nothing was resubmitted.";
+var DEFINITE_OTP_FAILURES = /* @__PURE__ */ new Set(["otp_rejected", "attempt_replaced", "attempt_unavailable", "attempt_failed", "invalid_otp", "invalid_session_id"]);
+var defaultWait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+async function continueZerodhaLogin(session, options = {}) {
+  options.onStage?.("restoring");
+  return advanceLogin(session, await session.start(), options, { operatorLoginTried: false, earlierAttemptCancelled: false, attemptStarted: false, otpSubmitted: false });
+}
+async function logoutZerodha(session, options = {}) {
+  const wait = options.wait ?? defaultWait;
+  const now = options.now ?? Date.now;
+  options.onStage?.("restoring");
+  let current = await session.start();
+  let restoreDeadline;
+  for (; ; ) {
+    if (current.outcome === "uncertain") return { kind: "uncertain", message: UNCERTAIN_MESSAGE };
+    if (current.outcome === "failure") return { kind: "failed", message: current.error?.message ?? "The browser action failed." };
+    const sessionId = current.sessionId;
+    if (!sessionId) return { kind: "failed", message: "The browser session did not return a session ID." };
+    switch (current.authentication.status) {
+      case "zerodha_login_required":
+      case "operator_login_required":
+        return { kind: "logged_out", alreadyLoggedOut: true };
+      case "zerodha_session_restoring":
+        restoreDeadline ??= now() + RESTORE_DEADLINE_MS;
+        await wait(RESTORE_POLL_MS);
+        if (now() >= restoreDeadline) return { kind: "failed", message: "The Zerodha session is still restoring. Check the page with `lmt-web inspect`." };
+        current = await session.run(sessionId, "inspect");
+        continue;
+      case "authenticated": {
+        options.onStage?.("logging_out");
+        const result = await session.run(sessionId, "zerodha-logout");
+        if (result.outcome === "uncertain") return { kind: "uncertain", message: UNCERTAIN_MESSAGE };
+        if (result.outcome === "failure") return { kind: "failed", message: result.error?.message ?? "Zerodha logout failed." };
+        if (result.authentication.status === "zerodha_login_required") return { kind: "logged_out", alreadyLoggedOut: false };
+        return { kind: "failed", message: "Zerodha logout was not confirmed. Check the page with `lmt-web inspect`." };
+      }
+      default:
+        return { kind: "failed", message: "The browser page was not recognized as a Live Market Terminal surface." };
+    }
+  }
+}
+async function submitZerodhaOtp(session, input, options = {}) {
+  options.onStage?.("submitting_otp");
+  const submitted = await session.submitOtp(input.sessionId, input.attemptId, input.otp);
+  const authentication = submitted.authentication;
+  if (submitted.outcome === "failure") {
+    if (!DEFINITE_OTP_FAILURES.has(submitted.error?.code ?? "")) return { kind: "uncertain", message: UNCERTAIN_MESSAGE };
+    if (submitted.error?.code === "otp_rejected" && authentication.status === "zerodha_login_required" && authentication.nextAction === "zerodha-otp" && authentication.attemptId === input.attemptId) {
+      return { kind: "otp_required", sessionId: input.sessionId, attemptId: input.attemptId, message: submitted.error.message };
+    }
+  }
+  return advanceLogin(session, submitted, options, { operatorLoginTried: true, earlierAttemptCancelled: true, attemptStarted: true, otpSubmitted: true });
+}
+async function advanceLogin(session, initial, options, progress) {
+  const wait = options.wait ?? defaultWait;
+  const now = options.now ?? Date.now;
+  const tookAction = () => progress.otpSubmitted || progress.operatorLoginTried || progress.attemptStarted;
+  let current = initial;
+  let restoreDeadline;
+  for (; ; ) {
+    if (current.outcome === "uncertain") return { kind: "uncertain", message: UNCERTAIN_MESSAGE };
+    if (current.outcome === "failure") return { kind: "failed", message: current.error?.message ?? "The browser action failed." };
+    const sessionId = current.sessionId;
+    if (!sessionId) return { kind: "failed", message: "The browser session did not return a session ID." };
+    const authentication = current.authentication;
+    switch (authentication.status) {
+      case "authenticated":
+        return { kind: "authenticated", alreadyAuthenticated: !tookAction() };
+      case "operator_login_required":
+        if (progress.operatorLoginTried) return { kind: "failed", message: "Operator login did not complete. Check the Operator credentials in SMS." };
+        progress.operatorLoginTried = true;
+        options.onStage?.("operator_login");
+        current = await session.run(sessionId, "operator-login");
+        continue;
+      case "zerodha_login_required":
+        if (progress.attemptStarted && authentication.nextAction === "zerodha-otp") return { kind: "otp_required", sessionId, attemptId: authentication.attemptId };
+        if (!progress.attemptStarted && authentication.nextAction !== "zerodha-login") {
+          if (progress.earlierAttemptCancelled) return { kind: "failed", message: "An earlier Zerodha Login Attempt could not be cancelled. Check the page with `lmt-web inspect`." };
+          progress.earlierAttemptCancelled = true;
+          options.onStage?.("cancelling_attempt");
+          current = await session.run(sessionId, "zerodha-cancel");
+          continue;
+        }
+        if (progress.attemptStarted) return { kind: "failed", message: "The Zerodha Login Attempt is no longer accepting an OTP. Choose Login to Zerodha again." };
+        progress.attemptStarted = true;
+        options.onStage?.("starting_attempt");
+        current = await session.run(sessionId, "zerodha-login");
+        continue;
+      case "zerodha_session_restoring":
+        if (restoreDeadline === void 0) {
+          restoreDeadline = now() + RESTORE_DEADLINE_MS;
+          options.onStage?.("awaiting_session");
+        }
+        await wait(RESTORE_POLL_MS);
+        if (now() >= restoreDeadline) return { kind: "failed", message: "The Zerodha session is still restoring. Check the page with `lmt-web inspect`." };
+        current = await session.run(sessionId, "inspect");
+        continue;
+      default:
+        return { kind: "failed", message: "The browser page was not recognized as a Live Market Terminal login surface." };
+    }
+  }
+}
+function createInteractiveSession(deps) {
+  let startedSessionId;
+  let inFlight = 0;
+  const track = async (operation) => {
+    inFlight += 1;
+    try {
+      return await operation();
+    } finally {
+      inFlight -= 1;
+    }
+  };
+  return {
+    start: () => track(async () => {
+      const started = await deps.start();
+      if (started.result.sessionId) {
+        if (started.startedOwner) startedSessionId = started.result.sessionId;
+        else if (startedSessionId !== started.result.sessionId) startedSessionId = void 0;
+      }
+      return started.result;
+    }),
+    run: (sessionId, action) => track(() => deps.request({ sessionId, action })),
+    submitOtp: (sessionId, attemptId, otp) => track(() => deps.request({ sessionId, action: "zerodha-otp", attemptId, otp })),
+    async release() {
+      if (!startedSessionId || inFlight > 0) return;
+      const sessionId = startedSessionId;
+      startedSessionId = void 0;
+      await deps.request({ sessionId, action: "stop" });
+    }
+  };
+}
+
+// src/interactive-app.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+var STAGE_TEXT = {
+  restoring: "Restoring the saved browser session\u2026",
+  operator_login: "Completing Operator login\u2026",
+  cancelling_attempt: "Cancelling an earlier Zerodha login attempt\u2026",
+  starting_attempt: "Starting Login with Zerodha\u2026",
+  submitting_otp: "Submitting OTP\u2026",
+  awaiting_session: "Waiting for the Zerodha session\u2026",
+  logging_out: "Logging out of Zerodha\u2026"
+};
+var NOTICE_COLOR = { success: "green", error: "red", info: void 0 };
+function InteractiveApp({ session, environment, device, onQuit }) {
+  const { exit } = useApp();
+  const [step, setStep] = useState({ kind: "menu" });
+  const [selected, setSelected] = useState(0);
+  const [notice, setNotice] = useState(null);
+  const [otp, setOtp] = useState("");
+  const [otpError, setOtpError] = useState("");
+  const busy = useRef(false);
+  const onStage = (stage) => setStep({ kind: "working", stage });
+  async function settle(action) {
+    busy.current = true;
+    setNotice(null);
+    let outcome;
+    try {
+      outcome = await action();
+    } catch (error) {
+      outcome = { kind: "failed", message: error instanceof Error ? error.message : "The browser action failed." };
+    }
+    busy.current = false;
+    if (outcome.kind === "otp_required") {
+      setOtp("");
+      setOtpError(outcome.message ?? "");
+      setStep({ kind: "otp", sessionId: outcome.sessionId, attemptId: outcome.attemptId });
+      return;
+    }
+    setStep({ kind: "menu" });
+    if (outcome.kind === "authenticated") {
+      setNotice({ tone: "success", text: outcome.alreadyAuthenticated ? "Already logged in to Zerodha." : "Logged in to Zerodha." });
+    } else if (outcome.kind === "logged_out") {
+      setNotice({ tone: "success", text: outcome.alreadyLoggedOut ? "Already logged out of Zerodha." : "Logged out of Zerodha." });
+    } else {
+      setNotice({ tone: "error", text: outcome.message });
+    }
+  }
+  const items = [
+    { label: "Login to Zerodha", run: () => {
+      void settle(() => continueZerodhaLogin(session, { onStage }));
+    } },
+    { label: "Logout from Zerodha", run: () => {
+      setNotice(null);
+      setStep({ kind: "confirm_logout" });
+    } }
+  ];
+  const active = Math.min(selected, items.length - 1);
+  function submitOtp(value) {
+    if (step.kind !== "otp") return;
+    if (!/^\d{6}$/.test(value)) {
+      setOtp(value);
+      setOtpError("Enter the six digits of the OTP.");
+      return;
+    }
+    setOtp("");
+    const { sessionId, attemptId } = step;
+    void settle(() => submitZerodhaOtp(session, { sessionId, attemptId, otp: value }, { onStage }));
+  }
+  useInput((input, key) => {
+    if (busy.current) return;
+    if (step.kind === "menu") {
+      if (key.upArrow) setSelected((index) => (index - 1 + items.length) % items.length);
+      else if (key.downArrow) setSelected((index) => (index + 1) % items.length);
+      else if (key.return) items[active]?.run();
+      else if (input === "q") {
+        onQuit?.();
+        exit();
+      }
+      return;
+    }
+    if (step.kind === "confirm_logout") {
+      if (input === "y" || input === "Y") void settle(() => logoutZerodha(session, { onStage }));
+      else {
+        setStep({ kind: "menu" });
+        setNotice({ tone: "info", text: "Logout cancelled." });
+      }
+      return;
+    }
+    if (step.kind === "otp") {
+      if (key.escape) {
+        setOtp("");
+        setStep({ kind: "menu" });
+        setNotice({ tone: "info", text: "Zerodha login cancelled. No OTP was submitted." });
+      } else if (key.return) submitOtp(otp);
+      else if (key.backspace || key.delete) setOtp((value) => value.slice(0, -1));
+      else if (input && !key.ctrl && !key.meta) {
+        const value = (otp + input.replace(/\D/g, "")).slice(0, 6);
+        if (/[\r\n]/.test(input)) submitOtp(value);
+        else setOtp(value);
+      }
+    }
+  });
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", gap: 1, children: [
+    /* @__PURE__ */ jsx(Text, { bold: true, children: "Live Market Terminal Web" }),
+    step.kind === "menu" && /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+      items.map((item, index) => /* @__PURE__ */ jsxs(Text, { color: index === active ? "cyan" : void 0, bold: index === active, children: [
+        index === active ? "\u203A" : " ",
+        " ",
+        item.label
+      ] }, item.label)),
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: "\u2191/\u2193 to move \xB7 Enter to select \xB7 q to quit" })
+    ] }),
+    step.kind === "working" && /* @__PURE__ */ jsx(Text, { children: STAGE_TEXT[step.stage] }),
+    step.kind === "confirm_logout" && /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs(Text, { children: [
+        "Log out of Zerodha for ",
+        environment,
+        " \xB7 ",
+        device,
+        "?"
+      ] }),
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: "Agents restoring this saved session will need a new Zerodha login. y to confirm \xB7 any other key to cancel" })
+    ] }),
+    step.kind === "otp" && /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx(Text, { children: "Zerodha OTP" }),
+      /* @__PURE__ */ jsxs(Text, { children: [
+        "\u2022".repeat(otp.length),
+        /* @__PURE__ */ jsx(Text, { inverse: true, children: " " })
+      ] }),
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: "Enter to submit \xB7 Esc to cancel" }),
+      otpError ? /* @__PURE__ */ jsx(Text, { color: "red", children: otpError }) : null
+    ] }),
+    notice ? /* @__PURE__ */ jsx(Text, { color: NOTICE_COLOR[notice.tone], children: notice.text }) : null,
+    /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+      environment,
+      " \xB7 ",
+      device
+    ] })
+  ] });
+}
+
+// src/interactive-main.ts
+var ACTION_TIMEOUT_MS = 3e4;
+async function runInteractive(argv) {
+  const { environment, device } = parseInteractiveArguments(argv);
+  const session = createInteractiveSession({
+    start: () => startSession({ environment, mode: device, headless: true, fresh: false, timeoutMs: ACTION_TIMEOUT_MS }),
+    request: (request) => requestSession({ ...request, timeoutMs: ACTION_TIMEOUT_MS })
+  });
+  const app = render(createElement(InteractiveApp, { session, environment, device }));
+  try {
+    await app.waitUntilExit();
+  } finally {
+    await session.release().catch(() => void 0);
+  }
+}
+export {
+  runInteractive
+};

package/package.json

@@ -1,12 +1,14 @@
 {
   "name": "@ai-digital-factory/lmt-web-cli",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "type": "module",
   "bin": {
     "lmt-web": "dist/index.js"
   },
   "dependencies": {
-    "playwright": "^1.55.0"
+    "ink": "7.1.1",
+    "playwright": "^1.55.0",
+    "react": "19.2.8"
   },
   "description": "Standalone browser session CLI for Live Market Terminal Web.",
   "engines": {