@ai-digital-factory/lmt-cli 0.1.5 → 1.0.0

package/dist/menu-actions-HV2AY4KJ.js

@@ -0,0 +1,67 @@
+import {
+  installChromium,
+  listLiveOwners,
+  requestSession,
+  socketPathFor,
+  startSession
+} from "./chunk-AQIOT6YD.js";
+import {
+  resolveCliTarget
+} from "./chunk-4N3XUBM4.js";
+
+// src/web/menu-actions.ts
+import { lstat } from "node:fs/promises";
+import { Writable } from "node:stream";
+async function socketExists(sessionId) {
+  try {
+    return (await lstat(socketPathFor(sessionId))).isSocket();
+  } catch {
+    return false;
+  }
+}
+function createWebMenuActions(options) {
+  const { environment, timeoutMs } = options;
+  const fresh = /* @__PURE__ */ new Map();
+  const urls = /* @__PURE__ */ new Map();
+  const ended = /* @__PURE__ */ new Set();
+  const observe = (result) => {
+    if (result.sessionId && result.url) urls.set(result.sessionId, result.url);
+    return result;
+  };
+  return {
+    async start(input) {
+      const { result } = await startSession({ environment, ...input, timeoutMs, ...options.ownerScript ? { ownerScript: options.ownerScript } : {} });
+      if (input.fresh && result.sessionId && result.outcome !== "failure") fresh.set(result.sessionId, input.mode);
+      return observe(result);
+    },
+    async request(sessionId, action, fullPage) {
+      const result = await requestSession({ ...action, sessionId, timeoutMs, ...fullPage ? { fullPage } : {} });
+      if (action.action === "stop" || action.action === "close" || result.error?.code === "session_not_found") {
+        fresh.delete(sessionId);
+        urls.delete(sessionId);
+        if (result.outcome === "success" || result.error?.code === "session_not_found") ended.add(sessionId);
+        return result;
+      }
+      return observe(result);
+    },
+    async sessions() {
+      const { origin } = resolveCliTarget({ LMT_ENV: environment });
+      const registered = (await listLiveOwners()).filter((owner) => owner.environment === environment && owner.origin === origin).map((owner) => ({ sessionId: owner.sessionId, mode: owner.mode, fresh: false }));
+      const candidates = [...registered, ...[...fresh].map(([sessionId, mode]) => ({ sessionId, mode, fresh: true }))].filter((session) => !ended.has(session.sessionId));
+      const live = await Promise.all(candidates.map(async (session) => await socketExists(session.sessionId) ? session : void 0));
+      return live.filter((session) => session !== void 0).map((session) => ({ ...session, url: urls.get(session.sessionId) ?? null }));
+    },
+    async installBrowser() {
+      let output = "";
+      const sink = new Writable({ write(chunk, _encoding, done) {
+        output = (output + chunk.toString()).slice(-4e3);
+        done();
+      } });
+      const code = await installChromium([], sink);
+      return { code, output: output.trim().split("\n").slice(-5).join("\n") };
+    }
+  };
+}
+export {
+  createWebMenuActions
+};

package/dist/src-MZYWVU46.js

@@ -0,0 +1,380 @@
+import {
+  createOperatorSessionActions,
+  downloadCandleExport,
+  hasArgumentOtp,
+  runHeadlessCli,
+  runOperatorSessionValidation,
+  runPairCommand,
+  runZerodhaAction,
+  runZerodhaValidation
+} from "./chunk-7J2U4G5L.js";
+import {
+  CliProfileStore,
+  assertClientProfileName,
+  ownerOf,
+  profileNameOf,
+  reportSessionStatus,
+  resolveCliTarget
+} from "./chunk-4N3XUBM4.js";
+
+// src/controller-actions.ts
+function createControllerActions(options) {
+  const { target, owner, store, timeoutMs } = options;
+  const fetchOption = options.fetchImpl ? { fetchImpl: options.fetchImpl } : {};
+  const smsOptions = {
+    ...options.readLoginCredentials ? { readLoginCredentials: options.readLoginCredentials } : {},
+    ...options.secretReader ? { secretReader: options.secretReader } : {}
+  };
+  const profile = profileNameOf(owner);
+  const callerProfile = profile === void 0 ? {} : { callerProfile: profile };
+  const operatorActions = (signal) => createOperatorSessionActions({
+    target,
+    profile: owner,
+    store,
+    timeoutMs,
+    ...signal ? { signal } : {},
+    ...fetchOption,
+    ...smsOptions
+  });
+  const authenticated = async (action) => {
+    const signal = AbortSignal.timeout(timeoutMs);
+    const actions = operatorActions(signal);
+    const api = await actions.getApi();
+    await actions.status();
+    return action(api, signal);
+  };
+  const zerodha = async (action, attemptId, otp) => {
+    const api = await operatorActions().getApi();
+    return runZerodhaAction(api, action, target.operatorId, AbortSignal.timeout(timeoutMs), attemptId, otp);
+  };
+  return {
+    async status() {
+      const { report } = await reportSessionStatus({
+        target,
+        owner,
+        store,
+        timeoutMs,
+        signal: AbortSignal.timeout(timeoutMs),
+        ...fetchOption
+      });
+      return report;
+    },
+    async unlockOperator() {
+      await operatorActions().loginFromSms();
+    },
+    startZerodhaLogin: () => zerodha("login"),
+    submitZerodhaOtp: (attemptId, otp) => zerodha("otp", attemptId, otp),
+    logout: () => operatorActions().logout(),
+    readSettings: () => authenticated((api) => api.getSettings()),
+    saveSettings: (patch) => authenticated((api) => api.saveSettings(patch)),
+    readToken: () => authenticated((api) => api.getTokenMetadata()),
+    replaceToken: (request) => authenticated((api) => api.replaceToken(request)),
+    exportCandles: (request, output) => authenticated(async (api, signal) => {
+      const candleExport = await api.exportCandles(request);
+      const download = output === void 0 ? void 0 : await downloadCandleExport(candleExport.url, output, signal, options.fetchImpl);
+      return { candleExport, ...download ? { download } : {} };
+    }),
+    pair: (action) => authenticated((api) => runPairCommand({ kind: "pair", environment: target.environment, ...action }, api)),
+    async zerodha(action, attemptId) {
+      await operatorActions().status();
+      return zerodha(action, attemptId);
+    },
+    validateOperatorSession: () => runOperatorSessionValidation({ target, store, ...callerProfile, ...fetchOption, ...smsOptions }),
+    validateZerodhaSession: (attemptId, otp) => runZerodhaValidation({
+      target,
+      store,
+      ...callerProfile,
+      ...fetchOption,
+      ...attemptId ? { attemptId } : {},
+      ...otp === void 0 ? {} : { readOtp: async () => otp }
+    })
+  };
+}
+
+// src/preferences.ts
+import { chmod, mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import path from "node:path";
+var PreferenceStore = class {
+  directory;
+  file;
+  constructor(homeDirectory = process.env.HOME ?? process.env.USERPROFILE ?? process.cwd()) {
+    this.directory = path.join(homeDirectory, ".lmt");
+    this.file = path.join(this.directory, "preferences.json");
+  }
+  /** The last confirmed environment, or undefined when none is stored or the file is unreadable. */
+  async readEnvironment() {
+    try {
+      const value = JSON.parse(await readFile(this.file, "utf8")).environment;
+      return value === "local" || value === "dev" ? value : void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  async saveEnvironment(environment) {
+    await mkdir(this.directory, { recursive: true, mode: 448 });
+    const temporary = `${this.file}.${process.pid}.tmp`;
+    await writeFile(temporary, `${JSON.stringify({ environment })}
+`, { mode: 384 });
+    await chmod(temporary, 384);
+    await rename(temporary, this.file);
+  }
+};
+
+// src/cli-env.ts
+function ensureFetchIgnoresEnvProxy() {
+  process.env.NODE_USE_ENV_PROXY = "0";
+}
+
+// src/help.ts
+function wantsCliHelp(argv) {
+  return argv.includes("--help") || argv.includes("-h") || argv[0] === "help";
+}
+var HEADLESS_COMMAND_USAGES = [
+  "login --env local|dev [--profile NAME] [--timeout DURATION]",
+  "logout --env local|dev [--profile NAME] [--timeout DURATION]",
+  "candle-export EXCHANGE:SYMBOL [--date YYYY-MM-DD] [--output PATH] --env local|dev [--profile NAME] [--timeout DURATION]",
+  "pair list --env local|dev [--profile NAME] [--timeout DURATION]",
+  "pair assign --ce ROW --pe ROW --lots N --env local|dev [--profile NAME] [--timeout DURATION]",
+  "pair unpair PAIR_ID --confirm --env local|dev [--profile NAME] [--timeout DURATION]",
+  "pair report PAIR_ID [--publish | --output PATH] --env local|dev [--profile NAME] [--timeout DURATION]",
+  "settings read --env local|dev [--profile NAME]",
+  "settings save --stdin --env local|dev [--profile NAME]",
+  "token read --env local|dev [--profile NAME]",
+  "token replace --stdin --env local|dev [--profile NAME]",
+  "status --env local|dev [--profile NAME] [--timeout DURATION]",
+  "zerodha login --env local|dev [--profile NAME] [--timeout DURATION]",
+  "zerodha observe --attempt ID --env local|dev [--profile NAME] [--timeout DURATION]",
+  "zerodha otp --attempt ID --otp-stdin --env local|dev [--profile NAME] [--timeout DURATION]",
+  "zerodha status --env local|dev [--profile NAME] [--timeout DURATION]",
+  "validate operator-session --env local|dev [--profile NAME] [--timeout DURATION]",
+  "validate zerodha-session --env local|dev [--profile NAME] [--attempt ID [--otp-stdin]] [--timeout DURATION]",
+  "credential provision --env local|dev --credential-stdin"
+];
+function formatCliHelp() {
+  return `Live Market Terminal CLI
+
+Usage (lmt is an alias of live-market-terminal):
+  live-market-terminal [--env local|dev] [--device mobile|desktop]
+  live-market-terminal interactive [--env local|dev] [--device mobile|desktop] [--profile NAME]
+  live-market-terminal credential provision [--env local|dev]
+${HEADLESS_COMMAND_USAGES.map((usage) => `  live-market-terminal ${usage}`).join("\n")}
+
+Headless options (--env, --profile, --timeout, --attempt, --otp-stdin, --credential-stdin) may appear before or after the command.
+
+From the monorepo root:
+  pnpm cli [--env local|dev]                      # interactive; without --env choose on the first screen
+  pnpm -s cli:headless status --env local   # build step runs quietly (-s)
+
+Candle Export publishes a new immutable workbook link and returns its context in candleExport JSON.
+Empty or unavailable sources are explained in the workbook. Export never starts Zerodha login or token recovery.
+
+Price Cross pair commands operate Paper pairs on the owning Broker through Gate; they never save Settings or place Orders.
+pair list returns current and past pairs (JSON pairs.active / pairs.past). Broker refusals keep their reason codes
+(invalid_lots, same_type, already_paired, order_in_flight, flag_disabled, ...) with exit 1.
+pair unpair requires --confirm and returns exit details (unpair.exit) when a paper position closed; a repeat reports already_unpaired.
+pair report downloads the lifetime workbook (default: server filename in the current directory, never overwritten);
+--publish returns a new immutable Hosted URL instead.
+A pair assign, unpair or publish timeout after submission is uncertain (exit 1); read pair list before resubmitting.
+The CLI never repeats a submission.
+
+Settings save reads one JSON object from stdin: expectedSettingsVersion plus selected rowCount,
+marketProtection, entryCategories, or complete credentials. Omitted fields are preserved.
+Token replace reads {accessToken?, expected, continueReplacement?, verifyCurrent?} from protected stdin.
+Use verifyCurrent: true with expected from token read to validate the saved token without supplying accessToken.
+Read token metadata through token read. A timeout after submission is uncertain; never retry blindly.
+
+Targets: local and dev only. Production is not permitted.
+
+Zerodha login is two steps: zerodha login, then zerodha otp --attempt ID --otp-stdin.
+Obtain the OTP from Kite after login returns awaiting_otp; expired attempts require a new login.
+OTP arguments (--otp CODE and --otp=CODE) are rejected. Pipe protected input; headless mode never prompts.
+
+Validate Zerodha Session starts a new attempt; resume the returned ID with --attempt ID.
+Supply --otp-stdin only when submitting a human OTP to that exact attempt.
+Validation retains the caller profile session and can replace Broker's active attempt or refresh its shared token.
+Interactive mode (a terminal is required) chooses the environment, then Log in establishes the Controller
+Session: the Operator is unlocked from SMS and only the Zerodha OTP is typed. Status and Log out are in the menu.
+Headless commands write one JSON object per line to stdout; diagnostics go to stderr.
+
+Controller Session: without --profile, every command uses the one Operator Session the Controller holds
+per environment, shared by every local Origin and worktree. login, zerodha login and zerodha otp establish it;
+logout ends it at Gate. --profile NAME uses an isolated CLI Client Profile instead and never touches it.
+status reports smsCredential, operatorSession and zerodha without creating or replacing a session;
+a session Gate rejects is cleared locally and reported expired.
+
+Exit codes (headless):
+  0 success or validation pass
+  1 action failure (including Gate or SMS unreachable)
+  2 invalid invocation or target
+  3 Operator Login required (--profile only)
+  4 blocked: Controller Session unusable (no valid Operator Session, Zerodha unauthenticated
+    or no SMS credential; nextStep says what to run), validation blocked, or Zerodha awaiting OTP
+
+Options:
+  --env local|dev       Target environment (interactive: skips the environment screen; headless: required)
+  --device mobile|desktop  Interactive only: remembered for the Web menu and shown in the header
+  --profile NAME        CLI Client Profile, an isolated session (default: the Controller Session)
+  --timeout DURATION    Action deadline, e.g. 45s, 2m, 30000ms (headless)
+  --ce ROW / --pe ROW   Market Watch rows for pair assign (CE leg, PE leg)
+  --lots N              Pair Lots for pair assign; the Broker enforces 1 through its configured maximum
+  --confirm             Required by pair unpair
+  --publish             pair report: publish an immutable snapshot and return its URL
+  --output PATH         pair report: write the downloaded workbook to PATH (overwrites)
+  --output PATH         candle-export: save workbook locally; refuses to overwrite an existing file
+  --date YYYY-MM-DD     Single IST date for candle-export; omitted: the exchange's latest completed trading day
+  --attempt ID          Attempt ID returned by zerodha login (required for observe and otp)
+  --otp-stdin           Read one six-digit OTP line from piped protected stdin (maximum 8 bytes)
+  --credential-stdin    Read SMS credential from piped stdin (headless provision; without it a terminal shows a masked prompt)
+  --help, -h            Show this help
+
+Storage: ~/.lmt/secrets.pem (one SMS credential shared by every command, including lmt web, the Controller Session
+per environment, and per-profile Gate cookies)
+`;
+}
+
+// src/index.ts
+var CliInvocationError = class extends Error {
+};
+var terminal = () => Boolean(process.stdin.isTTY && process.stdout.isTTY);
+function normalizeArgv(argv) {
+  return argv[0] === "--" ? argv.slice(1) : argv;
+}
+var INTERACTIVE_OPTIONS = /* @__PURE__ */ new Set(["--env", "--device"]);
+function hasOnlyInteractiveOptions(argv) {
+  if (argv.length % 2 !== 0) return false;
+  for (let index = 0; index < argv.length; index += 2) {
+    const value = argv[index + 1];
+    if (!INTERACTIVE_OPTIONS.has(argv[index]) || value.startsWith("--")) return false;
+  }
+  return true;
+}
+function resolveCliInvocation(argv, inTerminal = terminal()) {
+  if (argv[0] === "interactive") return { kind: "interactive", argv };
+  if (hasOnlyInteractiveOptions(argv)) return { kind: "interactive", argv: ["interactive", ...argv] };
+  if (inTerminal && argv[0] === "credential" && argv[1] === "provision" && !argv.includes("--credential-stdin")) {
+    return { kind: "interactive", argv: ["interactive", ...argv] };
+  }
+  return { kind: "headless", argv };
+}
+async function bootstrapCli(dependencies = {}) {
+  if (dependencies.runApplication) {
+    await dependencies.runApplication();
+    return;
+  }
+  const argv = normalizeArgv(process.argv.slice(2));
+  if (hasArgumentOtp(argv)) {
+    process.exitCode = await runHeadlessCli(argv);
+    return;
+  }
+  if (argv[0] === "web") {
+    const { runWebCli } = await import("./web-5HW6PMSA.js");
+    await runWebCli(argv.slice(1));
+    return;
+  }
+  if (wantsCliHelp(argv)) {
+    process.stdout.write(formatCliHelp());
+    return;
+  }
+  const invocation = resolveCliInvocation(argv);
+  if (invocation.kind === "headless") {
+    process.exitCode = await runHeadlessCli(invocation.argv);
+    return;
+  }
+  if (!terminal()) {
+    process.stderr.write(`Interactive mode requires a terminal. Use a headless command instead.
+
+${formatCliHelp()}`);
+    process.exitCode = 2;
+    return;
+  }
+  let parsed;
+  let environments;
+  try {
+    parsed = parseInteractiveArguments(invocation.argv);
+    if (parsed.environment) resolveCliTarget({ LMT_ENV: parsed.environment });
+    environments = ["local", "dev"].flatMap((environment) => {
+      try {
+        return [{ environment, origin: resolveCliTarget({ LMT_ENV: environment }).origin }];
+      } catch {
+        return [];
+      }
+    });
+  } catch (error) {
+    throw new CliInvocationError(error instanceof Error ? error.message : "Invalid interactive CLI configuration.");
+  }
+  if (environments.length === 0) throw new CliInvocationError("Neither local nor dev could be resolved from lmt.config.json.");
+  const store = new CliProfileStore();
+  const [{ createElement }, { render }] = await Promise.all([import("react"), import("ink")]);
+  if (parsed.credentialProvision) {
+    const { CredentialProvisionApp } = await import("./credential-app-QEFV6LZM.js");
+    const app2 = render(createElement(CredentialProvisionApp, { store }));
+    await app2.waitUntilExit();
+    return;
+  }
+  const [{ ControllerApp }, { createWebMenuActions }] = await Promise.all([import("./controller-app-UTLE4YVF.js"), import("./menu-actions-HV2AY4KJ.js")]);
+  const owner = ownerOf(parsed.profile);
+  const app = render(createElement(ControllerApp, {
+    environments,
+    ...parsed.environment ? { initialEnvironment: parsed.environment } : {},
+    preferences: new PreferenceStore(),
+    store,
+    actionsFor: (environment) => createControllerActions({
+      target: resolveCliTarget({ LMT_ENV: environment }),
+      owner,
+      store,
+      timeoutMs: 3e4
+    }),
+    ...parsed.profile ? { profile: parsed.profile } : {},
+    ...parsed.device ? { device: parsed.device } : {},
+    // lmt web browsers use the Controller Session, so a --profile Controller has no Web submenu.
+    ...parsed.profile ? {} : {
+      webActionsFor: (environment) => createWebMenuActions({ environment, timeoutMs: 3e4 })
+    }
+  }));
+  await app.waitUntilExit();
+}
+function parseInteractiveArguments(argv) {
+  const credentialProvision = argv[1] === "credential" && argv[2] === "provision";
+  const allowed = credentialProvision ? ["--env", "--profile"] : ["--env", "--profile", "--device"];
+  const values = /* @__PURE__ */ new Map();
+  for (let index = credentialProvision ? 3 : 1; index < argv.length; index += 2) {
+    const flag = argv[index];
+    const value = argv[index + 1];
+    if (!allowed.includes(flag) || value === void 0 || value.startsWith("--")) {
+      throw new Error(`Invalid interactive argument: ${flag}`);
+    }
+    if (values.has(flag)) throw new Error(`Argument ${flag} may be specified only once.`);
+    values.set(flag, value);
+  }
+  const environment = values.get("--env");
+  if (environment !== void 0 && environment !== "local" && environment !== "dev") {
+    throw new Error("--env must be local or dev; prod is not permitted.");
+  }
+  const device = values.get("--device");
+  if (device !== void 0 && device !== "mobile" && device !== "desktop") throw new Error("--device must be mobile or desktop.");
+  const profile = values.get("--profile");
+  if (profile !== void 0) assertClientProfileName(profile);
+  if (credentialProvision) return { ...environment ? { environment } : {}, credentialProvision };
+  return {
+    ...environment ? { environment } : {},
+    ...profile ? { profile } : {},
+    ...device ? { device } : {},
+    credentialProvision
+  };
+}
+function runCliMain() {
+  ensureFetchIgnoresEnvProxy();
+  bootstrapCli().catch((error) => {
+    const message = error instanceof Error ? error.message : "CLI failed to start.";
+    process.stderr.write(`${message}
+`);
+    process.exitCode = error instanceof CliInvocationError ? 2 : 1;
+  });
+}
+export {
+  bootstrapCli,
+  normalizeArgv,
+  parseInteractiveArguments,
+  resolveCliInvocation,
+  runCliMain
+};

package/dist/web-5HW6PMSA.js

@@ -0,0 +1,9 @@
+import {
+  installChromium,
+  runWebCli
+} from "./chunk-AQIOT6YD.js";
+import "./chunk-4N3XUBM4.js";
+export {
+  installChromium,
+  runWebCli
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-digital-factory/lmt-cli",
-  "version": "0.1.5",
+  "version": "1.0.0",
   "type": "module",
   "bin": {
     "live-market-terminal": "dist/index.js",
@@ -27,6 +27,7 @@
   },
   "dependencies": {
     "ink": "7.1.1",
+    "playwright": "^1.55.0",
     "react": "19.2.8"
   }
 }