Tokens update command added

Author: vprudnikoff

README.md

@@ -60,6 +60,15 @@ linkedin account list
 # Switch active account
 linkedin account switch "Vlad"
 
+# Update tokens for active account (e.g. after regenerating tokens on the dashboard)
+linkedin account update
+
+# Update tokens for a specific account
+linkedin account update "Vlad"
+
+# Non-interactive token update
+linkedin account update --linked-api-token=xxx --identification-token=yyy
+
 # Rename a saved account
 linkedin account rename "Vlad" --name "My Work Account"
 
@@ -772,6 +781,34 @@ linkedin account list
 
 The active account is marked with `*`.
 
+#### `account update`
+
+Update tokens for a saved account. Useful when your tokens were regenerated on the dashboard and you need to refresh them in the CLI.
+
+```bash
+linkedin account update [name] [flags]
+```
+
+| Arg | Required | Description |
+|-----|----------|-------------|
+| `name` | no | Account name (case-insensitive substring match). Defaults to active account. |
+
+| Flag | Type | Description |
+|------|------|-------------|
+| `--linked-api-token` | string | New Linked API Token (skips prompt) |
+| `--identification-token` | string | New Identification Token (skips prompt) |
+
+```bash
+# Update active account interactively
+linkedin account update
+
+# Update a specific account
+linkedin account update "Vlad"
+
+# Non-interactive (for scripts/CI)
+linkedin account update --linked-api-token=xxx --identification-token=yyy
+```
+
 #### `account switch`
 
 Switch the active LinkedIn account.

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@linkedapi/linkedin-cli",
-  "version": "1.0.6",
+  "version": "1.0.7",
   "description": "AI-agent-friendly CLI for controlling LinkedIn accounts and retrieving real-time data.",
   "author": "Linked API",
   "license": "MIT",

src/commands/account/update.ts

@@ -0,0 +1,148 @@
+import { findAccountByName, listAccounts, updateAccountTokens } from '@core/auth/config-store';
+import { buildClient } from '@core/client/build-client';
+import { EXIT_CODE } from '@core/errors/exit-codes';
+import { Args, Command, Flags } from '@oclif/core';
+import { readMaskedInput } from '@utils/masked-input';
+import { isStdinTty } from '@utils/tty';
+
+export default class AccountUpdate extends Command {
+  static override description = 'Update tokens for a saved LinkedIn account';
+
+  static override args = {
+    name: Args.string({
+      description:
+        'Account name to update (case-insensitive substring match). Defaults to active account.',
+    }),
+  };
+
+  static override flags = {
+    'linked-api-token': Flags.string({
+      description: 'New Linked API Token (for non-interactive use)',
+    }),
+    'identification-token': Flags.string({
+      description: 'New Identification Token (for non-interactive use)',
+    }),
+  };
+
+  static override examples = [
+    '<%= config.bin %> account update',
+    '<%= config.bin %> account update "John"',
+    '<%= config.bin %> account update --linked-api-token=xxx --identification-token=yyy',
+  ];
+
+  public async run(): Promise<void> {
+    const { args, flags } = await this.parse(AccountUpdate);
+
+    const account = this.resolveAccount(args.name);
+
+    if (!account) {
+      return;
+    }
+
+    let linkedApiToken: string;
+    let identificationToken: string;
+
+    if (flags['linked-api-token'] && flags['identification-token']) {
+      linkedApiToken = flags['linked-api-token'];
+      identificationToken = flags['identification-token'];
+    } else if (!isStdinTty()) {
+      process.stderr.write(`Cannot run interactive update in non-interactive mode.
+Use flags instead:
+
+  linkedin account update --linked-api-token=xxx --identification-token=yyy
+
+Get tokens at https://app.linkedapi.io\n`);
+      this.exit(EXIT_CODE.AUTH);
+      return;
+    } else {
+      process.stdout.write(
+        `Updating tokens for "${account.name}".\n` +
+          'Get new tokens at https://app.linkedapi.io\n\n',
+      );
+
+      linkedApiToken = await readMaskedInput('New Linked API Token: ', 'account_');
+      identificationToken = await readMaskedInput('New Identification Token: ', 'id_');
+    }
+
+    if (!linkedApiToken || !identificationToken) {
+      process.stderr.write('Both tokens are required.\n');
+      this.exit(EXIT_CODE.AUTH);
+      return;
+    }
+
+    process.stdout.write('Verifying tokens... ');
+
+    let accountName = '';
+
+    try {
+      const tempClient = buildClient({
+        linkedApiToken,
+        identificationToken,
+      });
+      const accountInfo = await tempClient.getAccountInfo();
+      accountName = accountInfo.data?.name ?? '';
+      process.stdout.write('OK\n');
+    } catch {
+      process.stdout.write('FAILED\n');
+      process.stderr.write(
+        '\nInvalid tokens. Make sure you copied the correct tokens from https://app.linkedapi.io\n',
+      );
+      this.exit(EXIT_CODE.AUTH);
+      return;
+    }
+
+    const displayName = accountName || account.name;
+
+    const updated = updateAccountTokens(account.identificationToken, {
+      name: displayName,
+      linkedApiToken,
+      identificationToken,
+    });
+
+    if (!updated) {
+      process.stderr.write('Failed to update account.\n');
+      this.exit(EXIT_CODE.GENERAL);
+      return;
+    }
+
+    process.stdout.write(`Account "${displayName}" updated successfully.\n`);
+  }
+
+  private resolveAccount(
+    nameQuery?: string,
+  ): { name: string; identificationToken: string } | undefined {
+    const accounts = listAccounts();
+
+    if (accounts.length === 0) {
+      process.stderr.write('No accounts configured. Run "linkedin setup" to add one.\n');
+      this.exit(EXIT_CODE.AUTH);
+      return undefined;
+    }
+
+    if (nameQuery) {
+      const account = findAccountByName(nameQuery);
+
+      if (!account) {
+        process.stderr.write(
+          `Account "${nameQuery}" not found. Run "linkedin account list" to see available accounts.\n`,
+        );
+        this.exit(EXIT_CODE.GENERAL);
+        return undefined;
+      }
+
+      return account;
+    }
+
+    const current = accounts.find((account) => account.isCurrent);
+
+    if (!current) {
+      process.stderr.write(
+        'No active account. Run "linkedin account list" to see available accounts.\n',
+      );
+      this.exit(EXIT_CODE.AUTH);
+      return undefined;
+    }
+
+    return current;
+  }
+}

src/core/auth/config-store.ts

@@ -225,6 +225,34 @@ export function findAccountByName(nameQuery: string): TAccountEntry | undefined
   return config.accounts.find((account) => account.name.toLowerCase().includes(lowerQuery));
 }
 
+export function updateAccountTokens(
+  oldIdentificationToken: string,
+  newTokens: { name: string; linkedApiToken: string; identificationToken: string },
+): boolean {
+  const config = readRawConfig();
+
+  if (!config) {
+    return false;
+  }
+
+  const index = config.accounts.findIndex(
+    (account) => account.identificationToken === oldIdentificationToken,
+  );
+
+  if (index < 0) {
+    return false;
+  }
+
+  config.accounts[index] = newTokens;
+
+  if (config.currentAccount === oldIdentificationToken) {
+    config.currentAccount = newTokens.identificationToken;
+  }
+
+  saveRawConfig(config);
+  return true;
+}
+
 export function renameAccount(identificationToken: string, newName: string): boolean {
   const config = readRawConfig();
 

src/core/errors/error-handler.ts

@@ -7,6 +7,7 @@ interface TCliError {
   error: string;
   message: string;
   workflowId?: string;
+  hint?: string;
 }
 
 export function mapLinkedApiErrorToCliError(error: LinkedApiError): TCliError {
@@ -28,6 +29,7 @@ export function mapLinkedApiErrorToCliError(error: LinkedApiError): TCliError {
         exitCode: EXIT_CODE.AUTH,
         error: error.type,
         message: error.message,
+        hint: 'Run "linkedin account update" to refresh your tokens.',
       };
 
     case 'subscriptionRequired':
@@ -81,4 +83,8 @@ export function writeErrorToStderr(cliError: TCliError): void {
   }
 
   process.stderr.write(JSON.stringify(output) + '\n');
+
+  if (cliError.hint) {
+    process.stderr.write(`\n${cliError.hint}\n`);
+  }
 }

src/utils/masked-input.ts

@@ -0,0 +1,41 @@
+export function readMaskedInput(prompt: string, visiblePrefix: string): Promise<string> {
+  return new Promise((resolve) => {
+    process.stdout.write(prompt);
+
+    const stdin = process.stdin;
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding('utf-8');
+
+    let input = '';
+
+    const onData = (str: string): void => {
+      for (const char of str) {
+        if (char === '\n' || char === '\r') {
+          stdin.setRawMode(false);
+          stdin.removeListener('data', onData);
+          stdin.pause();
+          process.stdout.write('\n');
+          resolve(input);
+          return;
+        } else if (char === '\u007F' || char === '\b') {
+          if (input.length > 0) {
+            input = input.slice(0, -1);
+            process.stdout.write('\b \b');
+          }
+        } else if (char === '\u0003') {
+          stdin.setRawMode(false);
+          process.stdout.write('\n');
+          process.exit(0);
+        } else if (char >= ' ') {
+          input += char;
+          const isInPrefix =
+            input.length <= visiblePrefix.length && visiblePrefix.startsWith(input);
+          process.stdout.write(isInPrefix ? char : '*');
+        }
+      }
+    };
+
+    stdin.on('data', onData);
+  });
+}