@agentrhq/webcmd 0.3.4 → 0.4.1

package/clis/_shared/site-auth.js

@@ -1,32 +1,37 @@
-import { AuthRequiredError, TimeoutError, getErrorMessage } from '@agentrhq/webcmd/errors';
+import { AuthRequiredError } from '@agentrhq/webcmd/errors';
 import { cli, Strategy } from '@agentrhq/webcmd/registry';
 
-const DEFAULT_TIMEOUT_SECONDS = 300;
-const POLL_INTERVAL_MS = 2000;
+const LOGIN_ACTION = 'Complete sign-in in the opened Webcmd browser, then tell the agent when you are done.';
 
-function normalizeIdentity(site, identity) {
+function normalizeIdentity(config, identity) {
   const row = identity && typeof identity === 'object' && !Array.isArray(identity)
     ? identity
     : {};
-  return { logged_in: true, site, ...row };
+  return { ...blankIdentity(config), ...row, logged_in: true, site: config.site };
 }
 
 function isAuthRequired(error) {
   return error instanceof AuthRequiredError;
 }
 
-async function tryProbe(config, page, phase) {
-  const probe = phase === 'poll' && config.poll ? config.poll : config.verify;
-  return normalizeIdentity(config.site, await probe(page, { phase }));
+async function tryProbe(config, page) {
+  return normalizeIdentity(config, await config.verify(page, { phase: 'identity' }));
 }
 
-function authHint(config) {
-  return `Run \`webcmd ${config.site} login\` to open the login page, then retry.`;
+function identityColumns(config) {
+  return config.columns ?? ['id', 'username', 'name'];
+}
+
+function blankIdentity(config) {
+  return Object.fromEntries(identityColumns(config).map((column) => [column, '']));
 }
 
 function commandColumns(config) {
-  const identityColumns = config.columns ?? ['id', 'username', 'name'];
-  return ['logged_in', 'site', ...identityColumns];
+  return ['logged_in', 'site', ...identityColumns(config)];
+}
+
+function loginColumns(config) {
+  return ['status', ...commandColumns(config), 'action', 'verify_command'];
 }
 
 function normalizeQuickCheck(result) {
@@ -62,6 +67,7 @@ export function registerSiteAuthCommands(config) {
     browser: true,
     navigateBefore: false,
     siteSession: 'persistent',
+    aliases: config.whoamiAliases ?? [],
     args: [],
     columns: commandColumns(config),
     authStatus: {
@@ -72,52 +78,43 @@ export function registerSiteAuthCommands(config) {
         ? { refresh: async (page, kwargs) => normalizeRefreshResult(await config.refresh(page, kwargs)) }
         : {}),
     },
-    func: async (page) => [await tryProbe(config, page, 'identity')],
+    func: async (page) => [await tryProbe(config, page)],
   });
 
   cli({
     site: config.site,
     name: 'login',
     access: 'write',
-    description: config.loginDescription ?? `Open ${config.site} login and wait until the browser session is authenticated`,
+    description: config.loginDescription ?? `Open ${config.site} login`,
     domain: config.domain,
     strategy: Strategy.COOKIE,
     browser: true,
     navigateBefore: false,
     defaultWindowMode: 'foreground',
     siteSession: 'persistent',
-    args: [
-      { name: 'timeout', type: 'int', default: DEFAULT_TIMEOUT_SECONDS, help: 'Maximum seconds to wait for the user to finish login' },
-    ],
-    columns: ['status', ...commandColumns(config)],
-    func: async (page, kwargs) => {
+    args: [],
+    columns: loginColumns(config),
+    func: async (page) => {
       try {
-        return [{ status: 'already_logged_in', ...await tryProbe(config, page, 'identity') }];
+        return [{
+          status: 'already_logged_in',
+          ...await tryProbe(config, page),
+          action: '',
+          verify_command: '',
+        }];
       } catch (error) {
         if (!isAuthRequired(error)) throw error;
       }
 
       await openLogin(page);
-      const timeoutSeconds = Number(kwargs.timeout ?? DEFAULT_TIMEOUT_SECONDS);
-      const deadline = Date.now() + timeoutSeconds * 1000;
-      let lastAuthMessage = '';
-
-      while (Date.now() < deadline) {
-        await page.wait(Math.min(POLL_INTERVAL_MS / 1000, Math.max(0.2, (deadline - Date.now()) / 1000)));
-        try {
-          const identity = await tryProbe(config, page, 'poll');
-          return [{ status: 'login_complete', ...identity }];
-        } catch (error) {
-          if (!isAuthRequired(error)) throw error;
-          lastAuthMessage = getErrorMessage(error);
-        }
-      }
-
-      throw new TimeoutError(
-        `${config.site} login`,
-        timeoutSeconds,
-        lastAuthMessage ? `${authHint(config)} Last auth check: ${lastAuthMessage}` : authHint(config),
-      );
+      return [{
+        status: 'action_required',
+        logged_in: false,
+        site: config.site,
+        ...blankIdentity(config),
+        action: LOGIN_ACTION,
+        verify_command: `webcmd ${config.site} whoami`,
+      }];
     },
   });
 }

package/clis/_shared/site-auth.test.js

@@ -1,5 +1,5 @@
 import { describe, expect, it, vi } from 'vitest';
-import { AuthRequiredError, TimeoutError } from '@agentrhq/webcmd/errors';
+import { AuthRequiredError } from '@agentrhq/webcmd/errors';
 import { getRegistry } from '@agentrhq/webcmd/registry';
 import { registerSiteAuthCommands } from './site-auth.js';
 
@@ -11,12 +11,13 @@ function pageMock() {
 }
 
 describe('site auth command helper', () => {
-  it('registers whoami and foreground login commands', () => {
+  it('registers whoami aliases and foreground login columns', () => {
     registerSiteAuthCommands({
       site: 'auth-helper-registration',
       domain: 'example.com',
       loginUrl: 'https://example.com/login',
       columns: ['username'],
+      whoamiAliases: ['auth-status'],
       verify: async () => ({ username: 'alice' }),
     });
 
@@ -24,16 +25,23 @@ describe('site auth command helper', () => {
       access: 'read',
       browser: true,
       navigateBefore: false,
+      aliases: ['auth-status'],
       columns: ['logged_in', 'site', 'username'],
     });
-    expect(getRegistry().get('auth-helper-registration/login')).toMatchObject({
+    expect(getRegistry().get('auth-helper-registration/auth-status'))
+      .toBe(getRegistry().get('auth-helper-registration/whoami'));
+    const login = getRegistry().get('auth-helper-registration/login');
+    expect(login).toMatchObject({
       access: 'write',
       browser: true,
       navigateBefore: false,
       defaultWindowMode: 'foreground',
       siteSession: 'persistent',
-      columns: ['status', 'logged_in', 'site', 'username'],
     });
+    expect(login.args).toEqual([]);
+    expect(login.columns).toEqual([
+      'status', 'logged_in', 'site', 'username', 'action', 'verify_command',
+    ]);
   });
 
   it('whoami returns normalized identity without opening login', async () => {
@@ -55,44 +63,123 @@ describe('site auth command helper', () => {
     expect(page.goto).not.toHaveBeenCalled();
   });
 
-  it('login opens the login URL and polls until authenticated', async () => {
-    const poll = vi.fn()
-      .mockRejectedValueOnce(new AuthRequiredError('example.com', 'not yet'))
-      .mockResolvedValueOnce({ username: 'alice' });
+  it('login returns the existing authenticated identity', async () => {
+    registerSiteAuthCommands({
+      site: 'auth-helper-authenticated',
+      domain: 'example.com',
+      loginUrl: 'https://example.com/login',
+      columns: ['username'],
+      verify: async () => ({ username: 'alice' }),
+    });
+    const login = getRegistry().get('auth-helper-authenticated/login');
+    const page = pageMock();
+
+    await expect(login.func(page, {})).resolves.toEqual([{
+      status: 'already_logged_in',
+      logged_in: true,
+      site: 'auth-helper-authenticated',
+      username: 'alice',
+      action: '',
+      verify_command: '',
+    }]);
+    expect(page.goto).not.toHaveBeenCalled();
+  });
+
+  it('completes and canonicalizes successful identity rows', async () => {
+    registerSiteAuthCommands({
+      site: 'auth-helper-canonical',
+      domain: 'example.com',
+      loginUrl: 'https://example.com/login',
+      columns: ['username', 'name'],
+      verify: async () => ({
+        logged_in: false,
+        site: 'wrong-site',
+        username: 'alice',
+        extra: 'preserved',
+      }),
+    });
+    const page = pageMock();
+    const identity = {
+      logged_in: true,
+      site: 'auth-helper-canonical',
+      username: 'alice',
+      name: '',
+      extra: 'preserved',
+    };
+
+    await expect(getRegistry().get('auth-helper-canonical/whoami').func(page, {}))
+      .resolves.toEqual([identity]);
+    await expect(getRegistry().get('auth-helper-canonical/login').func(page, {}))
+      .resolves.toEqual([{
+        status: 'already_logged_in',
+        ...identity,
+        action: '',
+        verify_command: '',
+      }]);
+  });
+
+  it('opens the default login URL and returns an immediate handoff', async () => {
     registerSiteAuthCommands({
       site: 'auth-helper-login',
       domain: 'example.com',
       loginUrl: 'https://example.com/login',
       columns: ['username'],
       verify: async () => { throw new AuthRequiredError('example.com', 'missing'); },
-      poll,
     });
-    const cmd = getRegistry().get('auth-helper-login/login');
+    const login = getRegistry().get('auth-helper-login/login');
     const page = pageMock();
 
-    await expect(cmd.func(page, { timeout: 1 })).resolves.toEqual([{
-      status: 'login_complete',
-      logged_in: true,
+    expect(login.args).toEqual([]);
+    expect(login.columns).toEqual([
+      'status', 'logged_in', 'site', 'username', 'action', 'verify_command',
+    ]);
+    await expect(login.func(page, {})).resolves.toEqual([{
+      status: 'action_required',
+      logged_in: false,
       site: 'auth-helper-login',
-      username: 'alice',
+      username: '',
+      action: 'Complete sign-in in the opened Webcmd browser, then tell the agent when you are done.',
+      verify_command: 'webcmd auth-helper-login whoami',
     }]);
     expect(page.goto).toHaveBeenCalledWith('https://example.com/login');
-    expect(page.wait).toHaveBeenCalled();
-    expect(poll).toHaveBeenCalledTimes(2);
+    expect(page.wait).not.toHaveBeenCalled();
   });
 
-  it('login times out when auth never completes', async () => {
+  it('uses a custom opener for the immediate handoff', async () => {
+    const openLogin = vi.fn().mockResolvedValue(undefined);
     registerSiteAuthCommands({
-      site: 'auth-helper-timeout',
+      site: 'auth-helper-custom-login',
       domain: 'example.com',
       loginUrl: 'https://example.com/login',
       verify: async () => { throw new AuthRequiredError('example.com', 'missing'); },
-      poll: async () => { throw new AuthRequiredError('example.com', 'still missing'); },
+      openLogin,
     });
-    const cmd = getRegistry().get('auth-helper-timeout/login');
+    const login = getRegistry().get('auth-helper-custom-login/login');
     const page = pageMock();
 
-    await expect(cmd.func(page, { timeout: 0 })).rejects.toBeInstanceOf(TimeoutError);
-    expect(page.goto).toHaveBeenCalledWith('https://example.com/login');
+    await login.func(page, {});
+    expect(openLogin).toHaveBeenCalledOnce();
+    expect(page.goto).not.toHaveBeenCalled();
+  });
+
+  it('propagates non-auth probe and opener errors', async () => {
+    registerSiteAuthCommands({
+      site: 'auth-helper-probe-error',
+      domain: 'example.com',
+      loginUrl: 'https://example.com/login',
+      verify: async () => { throw new Error('probe broke'); },
+    });
+    registerSiteAuthCommands({
+      site: 'auth-helper-open-error',
+      domain: 'example.com',
+      loginUrl: 'https://example.com/login',
+      verify: async () => { throw new AuthRequiredError('example.com', 'missing'); },
+      openLogin: async () => { throw new Error('open broke'); },
+    });
+
+    await expect(getRegistry().get('auth-helper-probe-error/login').func(pageMock(), {}))
+      .rejects.toThrow('probe broke');
+    await expect(getRegistry().get('auth-helper-open-error/login').func(pageMock(), {}))
+      .rejects.toThrow('open broke');
   });
 });

package/clis/amazon/auth.js

@@ -44,10 +44,4 @@ registerSiteAuthCommands({
   columns: ['user_name'],
   quickCheck: hasAmazonSessionCookies,
   verify: verifyAmazonIdentity,
-  poll: async (page) => {
-    if (!await hasAmazonSessionCookies(page)) {
-      throw new AuthRequiredError('amazon.com', 'Waiting for Amazon at-main / x-main cookie');
-    }
-    return verifyAmazonIdentity(page);
-  },
 });

package/clis/band/auth.js

@@ -53,10 +53,4 @@ registerSiteAuthCommands({
   columns: ['user_id'],
   quickCheck: hasBandSessionCookie,
   verify: verifyBandIdentity,
-  poll: async (page) => {
-    if (!await hasBandSessionCookie(page)) {
-      throw new AuthRequiredError('band.us', 'Waiting for Band band_session cookie');
-    }
-    return verifyBandIdentity(page);
-  },
 });

package/clis/blinkit/auth.js

@@ -1,9 +1,7 @@
-import { AuthRequiredError, TimeoutError } from '@agentrhq/webcmd/errors';
-import { cli, Strategy } from '@agentrhq/webcmd/registry';
+import { AuthRequiredError } from '@agentrhq/webcmd/errors';
+import { registerSiteAuthCommands } from '../_shared/site-auth.js';
 import { BASE, DOMAIN } from './utils.js';
 
-const DEFAULT_TIMEOUT_SECONDS = 300;
-
 async function probeBlinkitIdentity(page) {
   const probe = await page.evaluate(`
     (() => {
@@ -50,46 +48,21 @@ function buildOpenLoginEvaluate() {
   `;
 }
 
-cli({
+registerSiteAuthCommands({
   site: 'blinkit',
-  name: 'login',
-  access: 'write',
-  description: 'Open Blinkit login and wait until the browser session is authenticated',
   domain: DOMAIN,
-  strategy: Strategy.COOKIE,
-  browser: true,
-  navigateBefore: false,
-  defaultWindowMode: 'foreground',
-  siteSession: 'persistent',
-  args: [
-    { name: 'timeout', type: 'int', default: DEFAULT_TIMEOUT_SECONDS, help: 'Maximum seconds to wait for the user to finish login' },
-  ],
-  columns: ['status', 'logged_in', 'phone', 'user_id'],
-  func: async (page, kwargs) => {
+  loginUrl: BASE,
+  columns: ['phone', 'user_id'],
+  verify: async (page) => {
     await page.goto(BASE);
     await page.wait(1);
-    try {
-      const identity = await probeBlinkitIdentity(page);
-      return [{ status: 'already_logged_in', logged_in: true, ...identity }];
-    } catch (error) {
-      if (!(error instanceof AuthRequiredError)) throw error;
-    }
-
-    const opened = await page.evaluate(buildOpenLoginEvaluate()).catch(() => null);
-    const timeoutSeconds = Number(kwargs.timeout ?? DEFAULT_TIMEOUT_SECONDS);
-    const deadline = Date.now() + timeoutSeconds * 1000;
-    let lastMessage = opened?.opened ? '' : opened?.detail || '';
-    while (Date.now() < deadline) {
-      await page.wait(2);
-      try {
-        const identity = await probeBlinkitIdentity(page);
-        return [{ status: 'login_complete', logged_in: true, ...identity }];
-      } catch (error) {
-        if (!(error instanceof AuthRequiredError)) throw error;
-        lastMessage = error.message;
-      }
-    }
-    throw new TimeoutError('blinkit login', timeoutSeconds, lastMessage || 'Finish OTP login in the opened Blinkit tab and retry.');
+    return probeBlinkitIdentity(page);
+  },
+  openLogin: async (page) => {
+    await page.goto(BASE);
+    await page.wait(1);
+    const result = await page.evaluate(buildOpenLoginEvaluate());
+    if (!result?.opened) throw new Error(`Blinkit login dialog did not open: ${result?.detail || 'unknown reason'}`);
   },
 });
 

package/clis/blinkit/blinkit.test.js

@@ -1,4 +1,4 @@
-import { describe, expect, it } from 'vitest';
+import { describe, expect, it, vi } from 'vitest';
 import { ArgumentError } from '@agentrhq/webcmd/errors';
 import { getRegistry } from '@agentrhq/webcmd/registry';
 import { __test__ as authTest } from './auth.js';
@@ -143,11 +143,48 @@ describe('blinkit helpers', () => {
 
 describe('blinkit registry shape', () => {
   it('registers the buying-path commands', () => {
-    for (const name of ['login', 'location', 'search', 'product', 'add-to-cart', 'cart', 'checkout', 'place-order']) {
+    for (const name of ['login', 'whoami', 'location', 'search', 'product', 'add-to-cart', 'cart', 'checkout', 'place-order']) {
       expect(getRegistry().get(`blinkit/${name}`)).toBeDefined();
     }
   });
 
+  it('opens login without waiting for manual authentication', async () => {
+    const login = getRegistry().get('blinkit/login');
+    const whoami = getRegistry().get('blinkit/whoami');
+    const page = {
+      goto: vi.fn().mockResolvedValue(undefined),
+      wait: vi.fn().mockResolvedValue(undefined),
+      evaluate: vi.fn()
+        .mockResolvedValueOnce({ kind: 'auth', detail: 'Blinkit login button is still visible' })
+        .mockResolvedValueOnce({ opened: true }),
+    };
+
+    expect(login.args).toEqual([]);
+    expect(login.columns).toEqual(expect.arrayContaining(['action', 'verify_command']));
+    expect(whoami).toBeDefined();
+    await expect(login.func(page, {})).resolves.toEqual([expect.objectContaining({
+      status: 'action_required',
+      logged_in: false,
+      site: 'blinkit',
+      verify_command: 'webcmd blinkit whoami',
+    })]);
+    expect(page.wait).not.toHaveBeenCalledWith(2);
+  });
+
+  it('rejects when the Blinkit login dialog cannot be opened', async () => {
+    const login = getRegistry().get('blinkit/login');
+    const page = {
+      goto: vi.fn().mockResolvedValue(undefined),
+      wait: vi.fn().mockResolvedValue(undefined),
+      evaluate: vi.fn()
+        .mockResolvedValueOnce({ kind: 'auth', detail: 'login required' })
+        .mockResolvedValueOnce({ opened: false, detail: 'login_button_missing' }),
+    };
+
+    await expect(login.func(page, {}))
+      .rejects.toThrow('Blinkit login dialog did not open: login_button_missing');
+  });
+
   it('marks only cart-changing commands as write', () => {
     expect(getRegistry().get('blinkit/search').access).toBe('read');
     expect(getRegistry().get('blinkit/product').access).toBe('read');

package/clis/chatgpt/auth.js

@@ -43,10 +43,4 @@ registerSiteAuthCommands({
   columns: ['user_id', 'name'],
   quickCheck: hasChatgptSessionCookie,
   verify: verifyChatgptIdentity,
-  poll: async (page) => {
-    if (!await hasChatgptSessionCookie(page)) {
-      throw new AuthRequiredError('chatgpt.com', 'Waiting for ChatGPT session cookie');
-    }
-    return verifyChatgptIdentity(page);
-  },
 });

package/clis/claude/auth.js

@@ -46,10 +46,4 @@ registerSiteAuthCommands({
   columns: ['user_id', 'org_name', 'org_uuid'],
   quickCheck: hasClaudeSessionCookie,
   verify: verifyClaudeIdentity,
-  poll: async (page) => {
-    if (!await hasClaudeSessionCookie(page)) {
-      throw new AuthRequiredError('claude.ai', 'Waiting for Claude sessionKey cookie');
-    }
-    return verifyClaudeIdentity(page);
-  },
 });

package/clis/coupang/auth.js

@@ -39,10 +39,4 @@ registerSiteAuthCommands({
   loginUrl: 'https://login.coupang.com/login/login.pang',
   columns: ['name'],
   verify: verifyCoupangIdentity,
-  poll: async (page) => {
-    if (!await hasCoupangSessionCookie(page)) {
-      throw new AuthRequiredError('coupang.com', 'Waiting for Coupang session cookies');
-    }
-    return verifyCoupangIdentity(page);
-  },
 });

package/clis/district/auth.js

@@ -37,8 +37,6 @@ registerSiteAuthCommands({
     await page.wait(1);
     return profileProbe(page);
   },
-  // While the OTP modal is open, probe without navigating away from it.
-  poll: async (page) => profileProbe(page),
   quickCheck: async (page) => {
     try {
       return { logged_in: true, ...await profileProbe(page) };

package/clis/facebook/auth.js

@@ -34,10 +34,4 @@ registerSiteAuthCommands({
   columns: ['user_id', 'vanity', 'profile_url'],
   quickCheck: hasFacebookCUserCookie,
   verify: verifyFacebookIdentity,
-  poll: async (page) => {
-    if (!await hasFacebookCUserCookie(page)) {
-      throw new AuthRequiredError('www.facebook.com', 'Waiting for Facebook c_user cookie');
-    }
-    return verifyFacebookIdentity(page);
-  },
 });

package/clis/gemini/auth.js

@@ -39,10 +39,4 @@ registerSiteAuthCommands({
   columns: ['name'],
   quickCheck: hasGoogleSessionCookie,
   verify: verifyGeminiIdentity,
-  poll: async (page) => {
-    if (!await hasGoogleSessionCookie(page)) {
-      throw new AuthRequiredError('gemini.google.com', 'Waiting for Google session cookies');
-    }
-    return verifyGeminiIdentity(page);
-  },
 });

package/clis/github/auth.js

@@ -35,10 +35,4 @@ registerSiteAuthCommands({
   columns: ['id', 'username', 'name', 'url'],
   quickCheck: hasGithubSessionCookies,
   verify: verifyGithubIdentity,
-  poll: async (page) => {
-    if (!await hasGithubSessionCookies(page)) {
-      throw new AuthRequiredError('github.com', 'Waiting for GitHub session cookies');
-    }
-    return verifyGithubIdentity(page);
-  },
 });

package/clis/grok/auth.js

@@ -43,10 +43,4 @@ registerSiteAuthCommands({
   columns: ['user_id', 'name'],
   quickCheck: hasGrokSessionCookie,
   verify: verifyGrokIdentity,
-  poll: async (page) => {
-    if (!await hasGrokSessionCookie(page)) {
-      throw new AuthRequiredError('grok.com', 'Waiting for Grok session cookie');
-    }
-    return verifyGrokIdentity(page);
-  },
 });

package/clis/hackernews/hackernews.test.js

@@ -1,6 +1,7 @@
 import { afterEach, describe, expect, it, vi } from 'vitest';
 import { getRegistry } from '@agentrhq/webcmd/registry';
 import { ArgumentError, EmptyResultError } from '@agentrhq/webcmd/errors';
+import { executePipeline } from '@agentrhq/webcmd/pipeline';
 import './top.js';
 import './best.js';
 import './ask.js';
@@ -34,10 +35,28 @@ describe('hackernews listing adapters expose item id', () => {
     expect(cmd?.columns).toEqual(['rank', 'id', 'title', 'author', 'url']);
     expect(cmd?.pipeline?.[5]?.map).toMatchObject({
       id: '${{ item.id }}',
-      url: '${{ item.url }}',
+      url: '${{ item.url || "https://news.ycombinator.com/item?id=" + item.id }}',
     });
   });
 
+  it('hackernews/jobs preserves external URLs and falls back to item pages', async () => {
+    const jobs = {
+      48995037: { id: 48995037, title: 'Text-only job', by: 'author' },
+      48954074: { id: 48954074, title: 'External job', by: 'author', url: 'https://example.com/job' },
+    };
+    vi.stubGlobal('fetch', vi.fn(async (url) => new Response(JSON.stringify(
+      String(url).endsWith('jobstories.json') ? [48995037, 48954074] : jobs[String(url).match(/item\/(\d+)\.json$/)?.[1]],
+    ), { status: 200 })));
+
+    const cmd = getRegistry().get('hackernews/jobs');
+    const result = await executePipeline(null, cmd?.pipeline ?? [], { args: { limit: 2 } });
+
+    expect(result).toEqual([
+      { rank: 1, id: 48995037, title: 'Text-only job', author: 'author', url: 'https://news.ycombinator.com/item?id=48995037' },
+      { rank: 2, id: 48954074, title: 'External job', author: 'author', url: 'https://example.com/job' },
+    ]);
+  });
+
   it('hackernews/search surfaces id (algolia objectID) alongside the existing columns', () => {
     const cmd = getRegistry().get('hackernews/search');
     expect(cmd?.columns).toEqual(['rank', 'id', 'title', 'score', 'author', 'comments', 'url']);

package/clis/hackernews/jobs.js

@@ -22,7 +22,7 @@ cli({
                 id: '${{ item.id }}',
                 title: '${{ item.title }}',
                 author: '${{ item.by }}',
-                url: '${{ item.url }}',
+                url: '${{ item.url || "https://news.ycombinator.com/item?id=" + item.id }}',
             } },
         { limit: '${{ args.limit }}' },
     ],

package/clis/hf/auth.js

@@ -1,8 +1,8 @@
 import { AuthRequiredError, CommandExecutionError } from '@agentrhq/webcmd/errors';
 import { registerSiteAuthCommands } from '../_shared/site-auth.js';
 
-// Hugging Face's `token` cookie is httpOnly; gate the login poll on the
-// documented /api/whoami-v2 endpoint (401 when anonymous) via a no-nav probe.
+// Hugging Face's `token` cookie is httpOnly; use the documented
+// /api/whoami-v2 endpoint (401 when anonymous) via a no-nav probe.
 const WHOAMI_PROBE = `(async () => {
   try {
     const r = await fetch('/api/whoami-v2', { credentials: 'include', headers: { Accept: 'application/json' } });
@@ -33,9 +33,4 @@ registerSiteAuthCommands({
   loginUrl: 'https://huggingface.co/login',
   columns: ['username', 'fullname', 'type'],
   verify: verifyHfIdentity,
-  poll: async (page) => {
-    const probe = await page.evaluate(WHOAMI_PROBE);
-    if (!probe?.ok) throw new AuthRequiredError('huggingface.co', 'Waiting for Hugging Face login');
-    return { username: probe.username, fullname: probe.fullname, type: probe.type };
-  },
 });

package/clis/instagram/auth.js

@@ -48,10 +48,4 @@ registerSiteAuthCommands({
   columns: ['user_id', 'username', 'full_name'],
   quickCheck: hasInstagramSessionCookie,
   verify: verifyInstagramIdentity,
-  poll: async (page) => {
-    if (!await hasInstagramSessionCookie(page)) {
-      throw new AuthRequiredError('www.instagram.com', 'Waiting for Instagram sessionid cookie');
-    }
-    return verifyInstagramIdentity(page);
-  },
 });

package/clis/linkedin/auth.js

@@ -53,10 +53,4 @@ registerSiteAuthCommands({
   columns: ['public_id', 'plain_id', 'name'],
   quickCheck: hasLinkedinSessionCookie,
   verify: verifyLinkedinIdentity,
-  poll: async (page) => {
-    if (!await hasLinkedinSessionCookie(page)) {
-      throw new AuthRequiredError('linkedin.com', 'Waiting for LinkedIn li_at cookie');
-    }
-    return verifyLinkedinIdentity(page);
-  },
 });