@ai-digital-factory/lmt-cli 0.1.3 → 0.1.4

package/README.md

@@ -205,3 +205,45 @@ node .github/scripts/test-lmt-cli-package.mjs "$tarball"
 `lmt validate zerodha-session --env local --profile NAME` starts a new Broker-owned attempt and returns an attributed blocked report when a human OTP is needed. Resume with the same profile and explicit `--attempt ID`; add `--otp-stdin` to submit the protected human code. Without that flag, the supplied attempt is only observed. A pass requires authoritative attempt state followed by a hard session check; status alone does not pass the scenario. The resulting session stays available on the caller profile.
 
 Interactive **Validate Zerodha Session** runs the same scenario with masked OTP input and a visible report. **Resume Zerodha Validation** asks for an explicit attempt ID. Fresh validation can replace the Operator's active Broker attempt and successful login can refresh its shared token. CLI profile isolation does not isolate that shared state. See [local/dev validation smoke steps and recorded prerequisites](ZERODHA-SMOKE.md).
+
+## Settings and token commands for Runner
+
+Read ordinary Settings and their durable Settings Version with:
+
+```sh
+lmt settings read --env dev --profile runner
+```
+
+Save one intent by piping a single JSON object to protected stdin. Supply the version
+you reviewed and only the settings you intend to change. For example:
+
+```sh
+printf '%s\n' '{"expectedSettingsVersion":7,"entryCategories":[]}' |
+  lmt settings save --stdin --env dev --profile runner
+```
+
+An empty list disables all Entry Categories; omitted fields keep their saved values.
+Replacing credentials requires all four fields (userId, password, apiKey, apiSecret)
+inside a credentials object supplied through protected stdin. Keep secrets in an
+owner-readable input file or a protected pipe, never in command arguments or shell history.
+One changed save advances one Settings Version; a current unchanged save returns
+unchanged without a write. Every ordinary API write, including standalone credential
+saves, requires expectedSettingsVersion. Stale saves return settings_conflict; read
+Settings again and review the intended changes before submitting. A transport timeout
+after submission or an unconfirmed Broker save returns uncertain with exit code 1.
+Commands never retry a save. An ambiguous SMS write blocks authoritative Settings
+reads and further Operator-record writes until Broker restarts and reloads its durable
+record. The existing Market Watch resize recovery limitation still applies across stores.
+
+Access-token operations use a separate version and endpoint:
+
+```sh
+lmt token read --env dev --profile runner
+lmt token replace --stdin --env dev --profile runner < /path/to/protected-token-request.json
+```
+
+The token request contains accessToken, expected (the metadata returned by token read),
+and optionally continueReplacement: true after reviewing an active-trading confirmation.
+A same-token submission verifies the submitter without reinstalling the token. Ordinary
+Settings Save never replaces access tokens. Token values and saved credentials do not
+appear in command results.

package/dist/index.js

@@ -15,7 +15,16 @@ var __export = (target, all) => {
 };
 
 // ../../packages/contracts/src/index.ts
-var OPERATOR_SESSION_EXPIRY_TRACE_GRACE_SECONDS, OPERATOR_SESSION_EXPIRY_WARNING_MS, DEFAULT_OPERATOR_SESSION_IDLE_HINT_SECONDS, ZERODHA_SESSION_ADMISSION_HEADER, ZERODHA_SESSION_ADMISSION_VERIFY, API_PATHS;
+function isOperatorMarketProtection(value) {
+  return typeof value === "number" && Number.isInteger(value) && value >= 2 && value <= 90;
+}
+function validateEntryCategories(value) {
+  if (!Array.isArray(value) || value.some((category) => typeof category !== "string" || !ENTRY_CATEGORIES.includes(category)) || new Set(value).size !== value.length) {
+    throw new Error("entryCategories must be a list of supported Entry Categories with no duplicates.");
+  }
+  return [...value];
+}
+var OPERATOR_SESSION_EXPIRY_TRACE_GRACE_SECONDS, OPERATOR_SESSION_EXPIRY_WARNING_MS, DEFAULT_OPERATOR_SESSION_IDLE_HINT_SECONDS, ZERODHA_SESSION_ADMISSION_HEADER, ZERODHA_SESSION_ADMISSION_VERIFY, ENTRY_CATEGORIES, API_PATHS;
 var init_src = __esm({
   "../../packages/contracts/src/index.ts"() {
     "use strict";
@@ -24,6 +33,16 @@ var init_src = __esm({
     DEFAULT_OPERATOR_SESSION_IDLE_HINT_SECONDS = 7 * 24 * 60 * 60;
     ZERODHA_SESSION_ADMISSION_HEADER = "x-lmt-session-admission";
     ZERODHA_SESSION_ADMISSION_VERIFY = "verify";
+    ENTRY_CATEGORIES = [
+      "NSE EQ",
+      "BSE EQ",
+      "NFO FUT",
+      "NFO CE",
+      "NFO PE",
+      "BFO FUT",
+      "BFO CE",
+      "BFO PE"
+    ];
     API_PATHS = {
       health: "/api/health",
       unlockOperatorSession: "/api/operator-session/unlock",
@@ -37,6 +56,9 @@ var init_src = __esm({
       operatorLoginEvents: "/api/operators/login/events",
       operatorLoginOtp: "/api/operators/login/otp",
       cancelOperatorLogin: "/api/operators/login/cancel",
+      zerodhaAccessToken: "/api/zerodha/access-token",
+      zerodhaAccessTokenRecovery: "/api/zerodha/access-token/recovery",
+      zerodhaAccessTokenPublication: "/api/zerodha/access-token/publication",
       zerodhaCredentials: "/api/zerodha/credentials",
       entryCategorySettings: "/api/settings/entry-categories",
       operatorSettings: "/api/settings",
@@ -272,7 +294,91 @@ function createGateApi(origin, fetchImpl = fetch, options = {}) {
     await rejectAbsentSession(response, path4);
     return response;
   }
+  async function settingsWrite(path4, body) {
+    let response;
+    try {
+      response = await fetchImpl(origin + path4, {
+        method: "PUT",
+        headers: headers({ "content-type": "application/json", accept: "application/json" }),
+        body: JSON.stringify(body),
+        signal: actionSignal()
+      });
+    } catch {
+      throw new SettingsActionError("submission_uncertain", true);
+    }
+    rememberCookies(response);
+    await rejectAbsentSession(response, path4);
+    if (!response.ok) {
+      const result = await readJson(response).catch(() => void 0);
+      const codes = [
+        "settings_conflict",
+        "settings_version_required",
+        "invalid_settings",
+        "trade_cycle_active",
+        "settings_save_failed",
+        "token_conflict",
+        "token_rejected",
+        "replacement_confirmation_required",
+        "token_write_pending",
+        "invalid_request",
+        "zerodha_session_absent",
+        "validation_failed",
+        "credentials_changed",
+        "replacement_blocked",
+        "token_changed",
+        "invalid_token_request",
+        "token_write_unresolved",
+        "active_trading_confirmation",
+        "validation_unavailable",
+        "unresolved_order",
+        "sharing_token_unavailable",
+        "token_recovery_unavailable",
+        "settings_recovery_required"
+      ];
+      const code = typeof result?.error === "string" && codes.includes(result.error) ? result.error : "operation_rejected";
+      throw new SettingsActionError(code, code === "settings_save_failed" || response.status >= 500);
+    }
+    return response;
+  }
+  function ordinarySettings(body) {
+    if (!body || !Number.isSafeInteger(body.settingsVersion) || !Number.isInteger(body.rowCount) || body.rowCount < 1 || body.rowCount > 20 || !isOperatorMarketProtection(body.marketProtection) || !Array.isArray(body.entryCategories)) {
+      throw new SettingsActionError("invalid_response");
+    }
+    return { settingsVersion: body.settingsVersion, rowCount: body.rowCount, marketProtection: body.marketProtection, entryCategories: validateEntryCategories(body.entryCategories) };
+  }
   const api = {
+    async getTokenMetadata() {
+      const response = await getJson(API_PATHS.zerodhaCredentials);
+      const body = await readJson(response);
+      if (!response.ok || !body?.accessTokenMetadata) throw new SettingsActionError("token_metadata_unavailable");
+      const { fingerprint, version, updatedAt, writePending } = body.accessTokenMetadata;
+      return { fingerprint, version, updatedAt, ...writePending === void 0 ? {} : { writePending } };
+    },
+    async getSettings() {
+      const response = await getJson(API_PATHS.operatorSettings);
+      if (!response.ok) throw new SettingsActionError("settings_read_failed");
+      return ordinarySettings(await readJson(response));
+    },
+    async saveSettings(request) {
+      const response = await settingsWrite(API_PATHS.operatorSettings, request);
+      try {
+        const body = await readJson(response);
+        if (body.outcome !== "saved" && body.outcome !== "unchanged") throw new Error("Invalid outcome");
+        return { outcome: body.outcome, settings: ordinarySettings(body.settings) };
+      } catch {
+        throw new SettingsActionError("submission_uncertain", true);
+      }
+    },
+    async replaceToken(request) {
+      const response = await settingsWrite(API_PATHS.zerodhaAccessToken, request);
+      try {
+        const body = await readJson(response);
+        if (body.outcome !== "verified" && body.outcome !== "replaced") throw new Error("Invalid outcome");
+        return { outcome: body.outcome, sharing: body.sharing, metadata: body.metadata, message: "Token operation completed." };
+      } catch {
+        throw new SettingsActionError("submission_uncertain", true);
+      }
+    },
     async exportCandles(request) {
       const response = await postJson(API_PATHS.candleExportOnDemand, request);
       const body = await readJson(response);
@@ -505,12 +611,21 @@ function createGateApi(origin, fetchImpl = fetch, options = {}) {
   };
   return api;
 }
-var OperatorSessionRejectedError, ZerodhaLoginFailedError, ZerodhaLoginAttemptUnavailableError, OperatorCredentialsRejectedError;
+var SettingsActionError, OperatorSessionRejectedError, ZerodhaLoginFailedError, ZerodhaLoginAttemptUnavailableError, OperatorCredentialsRejectedError;
 var init_gate_api_client = __esm({
   "src/gate-api-client.ts"() {
     "use strict";
     init_src();
     init_profile_name();
+    SettingsActionError = class extends Error {
+      constructor(code, uncertain = false) {
+        super(uncertain ? "Submission could not be confirmed. Read current Settings or token metadata before another submission." : code === "settings_conflict" ? "Settings changed elsewhere. Read saved Settings and submit again with its version." : code === "active_trading_confirmation" ? "Another device has active trading. Review it, then explicitly submit continueReplacement: true to continue." : code === "token_changed" ? "The token changed. Read token metadata and review a fresh submission." : code === "token_write_unresolved" ? "A token write is unresolved. Resolve interrupted save in Web before replacing." : code === "unresolved_order" ? "An Order remains unresolved. Reconcile it before replacing the token." : "The Settings or token operation was rejected.");
+        this.code = code;
+        this.uncertain = uncertain;
+      }
+      code;
+      uncertain;
+    };
     OperatorSessionRejectedError = class extends Error {
       constructor(reason) {
         super("The saved Operator Session was rejected by Gate.");
@@ -2489,7 +2604,23 @@ function splitHeadlessArgv(argv) {
   return { positional, options, credentialStdin, otpStdin };
 }
 function parseArguments(argv) {
-  const { positional, options, credentialStdin, otpStdin } = splitHeadlessArgv(argv);
+  const parsedInput = splitHeadlessArgv(argv.filter((value) => value !== "--stdin"));
+  const commandVerb = parsedInput.positional[0];
+  if (commandVerb === "settings" || commandVerb === "token") {
+    const stdin = argv.includes("--stdin");
+    if (argv.filter((value) => value === "--stdin").length > 1) throw new InvocationError("--stdin may be supplied only once.");
+    const parsed = parsedInput;
+    const [kind2, action] = parsed.positional;
+    if (parsed.positional.length !== 2 || parsed.credentialStdin || parsed.otpStdin || [...parsed.options.keys()].some((key) => !["--env", "--profile", "--timeout"].includes(key)) || !(kind2 === "settings" && (action === "read" && !stdin || action === "save" && stdin) || kind2 === "token" && (action === "replace" && stdin || action === "read" && !stdin))) {
+      throw new InvocationError("Use settings read, settings save --stdin, or token replace --stdin.");
+    }
+    const environment2 = parsed.options.get("--env"), profile2 = parsed.options.get("--profile");
+    if (!environment2 || !profile2) throw new InvocationError("Headless commands require --env local|dev and --profile NAME.");
+    validateCommandProfile(profile2);
+    return { kind: kind2, action, environment: environment2, profile: profile2, ...parsed.options.has("--timeout") ? { timeoutMs: parseTimeout(parsed.options.get("--timeout")) } : {} };
+  }
+  if (argv.includes("--stdin")) throw new InvocationError("--stdin is only supported for Settings save and token replacement.");
+  const { positional, options, credentialStdin, otpStdin } = parsedInput;
   if (positional[0] === "candle-export") {
     const instrument = positional[1]?.match(/^([A-Za-z][A-Za-z0-9]{0,31}):([^:\s]{1,100})$/);
     const date = options.get("--date");
@@ -2668,8 +2799,11 @@ async function readProtectedInput(stdin, signal, label = "SMS credential") {
 }
 async function runHeadlessCli(argv, dependencies = {}) {
   let otp;
+  let securePayload;
   const protect = (stream) => ({ write(chunk) {
-    return stream.write(otp ? chunk.replaceAll(otp, "[redacted]") : chunk);
+    let output = otp ? chunk.replaceAll(otp, "[redacted]") : chunk;
+    if (securePayload) output = output.replaceAll(securePayload, "[redacted]");
+    return stream.write(output);
   } });
   const streams = { stdout: protect(dependencies.stdout ?? defaultOut), stderr: protect(dependencies.stderr ?? defaultErr) };
   const started = performance.now();
@@ -2772,6 +2906,36 @@ async function runHeadlessCli(argv, dependencies = {}) {
       ...dependencies.readLoginCredentials ? { readLoginCredentials: dependencies.readLoginCredentials } : {}
     });
     actionApi = await actions.getApi();
+    if (command.kind === "settings" || command.kind === "token") {
+      await actions.status();
+      let payload;
+      if (command.action !== "read") {
+        securePayload = await readProtectedInput(dependencies.stdin ?? process.stdin, signal, "Settings JSON");
+        try {
+          payload = JSON.parse(securePayload);
+        } catch {
+          throw new InvocationError("Protected stdin must contain one JSON object.");
+        }
+        if (!payload || typeof payload !== "object" || Array.isArray(payload)) throw new InvocationError("Protected stdin must contain one JSON object.");
+      }
+      const settings = command.kind === "settings" ? command.action === "read" ? { outcome: "read", settings: await actionApi.getSettings() } : await actionApi.saveSettings(payload) : void 0;
+      const tokenMetadata = command.kind === "token" && command.action === "read" ? await actionApi.getTokenMetadata() : void 0;
+      const token = command.kind === "token" && command.action === "replace" ? await actionApi.replaceToken(payload) : void 0;
+      emit({
+        version: 1,
+        command: command.kind + " " + command.action,
+        outcome: "success",
+        reason: settings?.outcome ?? token?.outcome,
+        ...settings ? { settings: settings.settings } : {},
+        ...token ? { token } : {},
+        ...tokenMetadata ? { tokenMetadata } : {},
+        target: { environment: target.environment, origin: target.origin },
+        profile,
+        elapsedMs: Math.round(performance.now() - started),
+        metadata: { requestId: actionApi.responseMetadata().requestId ?? null, buildId: actionApi.responseMetadata().buildId ?? null }
+      }, streams);
+      return 0;
+    }
     if (command.kind === "candle-export") {
       await actions.status();
       const candleExport = await actionApi.exportCandles({
@@ -2855,13 +3019,13 @@ async function runHeadlessCli(argv, dependencies = {}) {
     if (error instanceof OperatorSessionRejectedError && store && actionApi && target && profile && !signal?.aborted) {
       await store.saveSession(profile, target, actionApi.getCookies()).catch(() => void 0);
     }
-    const details = errorDetails(error, signal);
+    const details = error instanceof SettingsActionError ? { code: error.code, message: error.message, exitCode: 1 } : errorDetails(error, signal);
     const recovery = error instanceof Error ? error : void 0;
     const attemptId = recovery?.attemptId ?? (command?.kind === "zerodha" ? command.attemptId : void 0);
     emit({
       version: 1,
-      command: command?.kind === "zerodha" ? `zerodha ${command.action}` : command?.kind === "credential-provision" ? "credential provision" : command?.kind === "validate-zerodha" ? "validate zerodha-session" : command?.kind === "validate" ? "validate operator-session" : command?.kind ?? "",
-      outcome: details.exitCode === 4 ? "blocked" : "fail",
+      command: command?.kind === "zerodha" || command?.kind === "settings" || command?.kind === "token" ? `${command.kind} ${command.action}` : command?.kind === "credential-provision" ? "credential provision" : command?.kind === "validate-zerodha" ? "validate zerodha-session" : command?.kind === "validate" ? "validate operator-session" : command?.kind ?? "",
+      outcome: error instanceof SettingsActionError && error.uncertain ? "uncertain" : details.exitCode === 4 ? "blocked" : "fail",
       reason: details.code,
       ...target ? { target: { environment: target.environment, origin: target.origin } } : command ? { target: { environment: command.environment } } : {},
       ...profile ? { profile } : {},
@@ -2878,6 +3042,7 @@ async function runHeadlessCli(argv, dependencies = {}) {
     return details.exitCode;
   } finally {
     otp = void 0;
+    securePayload = void 0;
     if (deadlineTimer) clearTimeout(deadlineTimer);
   }
 }
@@ -2906,6 +3071,10 @@ Usage (lmt is an alias of live-market-terminal):
   live-market-terminal login --env local|dev --profile NAME [--timeout DURATION]
   live-market-terminal logout --env local|dev --profile NAME [--timeout DURATION]
   live-market-terminal candle-export EXCHANGE:SYMBOL [--date YYYY-MM-DD] --env local|dev --profile NAME [--timeout DURATION]
+  live-market-terminal settings read --env local|dev --profile NAME
+  live-market-terminal settings save --stdin --env local|dev --profile NAME
+  live-market-terminal token read --env local|dev --profile NAME
+  live-market-terminal token replace --stdin --env local|dev --profile NAME
   live-market-terminal status --env local|dev --profile NAME [--timeout DURATION]
   live-market-terminal zerodha login --env local|dev --profile NAME [--timeout DURATION]
   live-market-terminal zerodha observe --attempt ID --env local|dev --profile NAME [--timeout DURATION]
@@ -2925,6 +3094,11 @@ From the monorepo root:
 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.
 
+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?} from protected stdin.
+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.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-digital-factory/lmt-cli",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "type": "module",
   "bin": {
     "live-market-terminal": "dist/index.js",