hirify-cli 0.4.2 → 0.4.4

package/README.md

@@ -5,6 +5,9 @@ account already has, search across the board, a vacancy in full, and the contact
 
 Node 18 or newer. No dependencies.
 
+A global installation checks for a new release when it starts and updates itself before running
+the command. Set `HIRIFY_NO_AUTO_UPDATE=1` only when the installed version must stay fixed.
+
 Install it globally with `npm install -g hirify-cli`, or run it without installing through `npx`
 as shown below. In either case, the command is `hirify` after a global install.
 

package/bin/hirify.js

@@ -15,7 +15,7 @@ import { homedir } from 'node:os'
 import { join, dirname } from 'node:path'
 import { fileURLToPath } from 'node:url'
 import { createServer } from 'node:http'
-import { spawn } from 'node:child_process'
+import { execFileSync, spawn, spawnSync } from 'node:child_process'
 import { randomBytes, createHash } from 'node:crypto'
 
 const API = process.env.HIRIFY_API || 'https://api.hirify.me'
@@ -61,10 +61,14 @@ const VERSION = (() => {
   }
 })()
 const USER_AGENT = `hirify-cli/${VERSION}`
+const PACKAGE_NAME = 'hirify-cli'
+const PACKAGE_LATEST = `https://registry.npmjs.org/${PACKAGE_NAME}/latest`
+const NPM = process.platform === 'win32' ? 'npm.cmd' : 'npm'
 
 const HELP = `hirify - job search for AI agents
 
   hirify intro                    what this can do, and in what order
+  hirify version                  installed version
 
   hirify login                    sign in through your browser       [--force]
   hirify logout                   sign out on this computer
@@ -114,6 +118,88 @@ const EXIT_MANIFEST_UNSUPPORTED = 2
 
 const die = (msg, code = EXIT_ERROR) => { console.error(`hirify: ${msg}`); process.exit(code) }
 
+/** Compare the public numeric part of two npm versions without adding a dependency. */
+function newerVersion(candidate, current) {
+  const parts = (value) => {
+    const match = String(value).match(/^(\d+)\.(\d+)\.(\d+)(?:-|$)/)
+    return match ? match.slice(1).map(Number) : null
+  }
+  const next = parts(candidate)
+  const installed = parts(current)
+  if (!next || !installed) return false
+  for (let i = 0; i < 3; i++) {
+    if (next[i] !== installed[i]) return next[i] > installed[i]
+  }
+  return false
+}
+
+/**
+ * A package launched from npx already follows the requested npm version. Only a global
+ * installation is ours to update: local project dependencies and the npx cache must not be
+ * changed behind their owner. `npm root -g` is asked only when this file is under node_modules,
+ * so a checkout and the test suite take no extra process or network trip.
+ */
+function isGlobalInstall() {
+  const script = fileURLToPath(import.meta.url)
+  if (!script.includes(`${join('node_modules', PACKAGE_NAME)}`)) return false
+  try {
+    const root = execFileSync(NPM, ['root', '-g'], {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+      timeout: 2000,
+    }).trim()
+    return script.startsWith(join(root, PACKAGE_NAME) + '/') || script.startsWith(join(root, PACKAGE_NAME) + '\\')
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Update a global installation before running the requested command. A failed registry check is
+ * silent because job search must keep working offline. A failed install leaves one exact recovery
+ * command and then continues with the installed version.
+ */
+async function autoUpdate() {
+  if (process.env.HIRIFY_NO_AUTO_UPDATE === '1' || !isGlobalInstall()) return false
+
+  const controller = new AbortController()
+  const timeout = setTimeout(() => controller.abort(), 2000)
+  let latest
+  try {
+    const response = await fetch(PACKAGE_LATEST, {
+      headers: { Accept: 'application/json', 'User-Agent': USER_AGENT },
+      signal: controller.signal,
+    })
+    if (!response.ok) return false
+    latest = (await response.json())?.version
+  } catch {
+    return false
+  } finally {
+    clearTimeout(timeout)
+  }
+
+  if (!newerVersion(latest, VERSION)) return false
+
+  console.error(`Updating Hirify CLI from ${VERSION} to ${latest}...`)
+  const update = spawnSync(NPM, ['install', '-g', `${PACKAGE_NAME}@latest`], {
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+    timeout: 120000,
+  })
+
+  if (update.status !== 0) {
+    console.error(`Hirify CLI ${latest} is available. Automatic update could not complete.`)
+    console.error(`Run: npm install -g ${PACKAGE_NAME}@latest`)
+    return false
+  }
+
+  console.error(`Hirify CLI updated to ${latest}.`)
+  const rerun = spawnSync(process.execPath, [fileURLToPath(import.meta.url), ...process.argv.slice(2)], {
+    stdio: 'inherit',
+  })
+  process.exit(rerun.status ?? EXIT_ERROR)
+}
+
 // Options that stand on their own. Everything else takes the next word as its value, and
 // that rule is what lets `search` carry a filter the CLI has never heard of: the list of
 // filters lives on the server, and a CLI that keeps its own copy is a CLI that lags.
@@ -185,14 +271,73 @@ const options = (args) => {
 const count = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : null)
 
 const out = (data, text) => {
-  if (process.argv.includes('--json')) console.log(JSON.stringify(data, null, 2))
-  else text()
+  if (process.argv.includes('--json')) {
+    // --json hands over the whole envelope, so a `meta.notice` on it travels structured and
+    // untouched. The human notice below is only for text mode.
+    console.log(JSON.stringify(data, null, 2))
+    return
+  }
+  text()
+  printNotice(data?.meta?.notice)
+}
+
+/**
+ * Print a structured notice the server attached to a successful answer (`meta.notice`). The
+ * call still succeeded, so this comes after the useful result, not in place of it. The CLI
+ * shows the text the server wrote and reads nothing into the policy behind it: it knows the
+ * notice object, not what produced it. No notice, or one with no message, prints nothing.
+ */
+function printNotice(notice) {
+  const message = typeof notice?.message === 'string' ? notice.message.trim() : ''
+  if (!message) return
+  console.log(`\nNotice: ${message}`)
 }
 
 // Text our own server wrote for the agent to read: application rules, address rejections.
 // Passing it through beats paraphrasing, because paraphrasing drifts from the real rule.
 const serverMessage = (body) => (typeof body?.message === 'string' && body.message ? body.message : null)
 
+/**
+ * The one-line report for a policy restriction: a canonical 403 that names itself
+ * `access_restricted`. It is kept apart from the quota and rate-limit walls on purpose,
+ * because those clear on their own and this one does not. The CLI states what the server
+ * sent - the message it wrote, when the restriction lifts, where to ask for a review - and
+ * adds no rule of its own about why it was applied.
+ */
+function accessRestrictedMessage(body) {
+  const err = (body && typeof body.error === 'object' && body.error) || {}
+  const line = (v) => (typeof v === 'string' && v.trim() ? v.trim() : null)
+  const parts = [line(err.message) || line(body?.message) || 'access on this account is restricted (403).']
+  const until = line(err.restricted_until)
+  if (until) parts.push(`It stays in place until ${until}.`)
+  const appeal = line(err.appeal_url)
+  if (appeal) parts.push(`To ask us to look at it again: ${appeal}`)
+  return parts.join('\n        ')
+}
+
+/**
+ * The report for a blocking notice: a canonical 409 that names itself `action_required`.
+ * Unlike a `meta.notice` on a success, this one stands in place of the answer - the server is
+ * holding the result until the person confirms - so the CLI shows the text the server wrote and
+ * the one command that clears it, and reads nothing into the policy behind it. That command is
+ * the acknowledgement capability the server lists in its manifest, reached the same way as any
+ * other, so no route to it is written here. It carries the notice's own id and its first
+ * advertised action, both as the server sent them, so the printed line runs as it stands.
+ */
+function actionRequiredMessage(body) {
+  const notice = (body && typeof body.error === 'object' && body.error && typeof body.error.notice === 'object' && body.error.notice) || {}
+  const line = (v) => (typeof v === 'string' && v.trim() ? v.trim() : null)
+  const parts = [line(notice.message) || 'this needs your confirmation before it can go ahead (409).']
+
+  const id = line(notice.id)
+  const action = Array.isArray(notice.actions) ? notice.actions.map(line).find(Boolean) : null
+  const call = 'hirify api call security.notices.ack'
+  parts.push(id && action
+    ? `To continue, acknowledge this notice: ${call} --data '${JSON.stringify({ id, action })}'`
+    : `To continue, acknowledge this notice: ${call}`)
+  return parts.join('\n        ')
+}
+
 const b64url = (buf) => buf.toString('base64').replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '')
 const now = () => Math.floor(Date.now() / 1000)
 
@@ -298,6 +443,27 @@ async function api(path, { method = 'GET', payload = null, allow = [], raw = fal
     return { status: res.status, body, text }
   }
 
+  // A policy restriction is a canonical 403 that names itself `access_restricted`. It is not a
+  // used-up allowance and not a rate limit, and retrying cannot lift it: the CLI reports it once
+  // and never retries. Checked ahead of `allow` so a caller that reads its own 403s still cannot
+  // take this one for an ordinary refusal. The clone leaves the body readable for the paths below.
+  if (res.status === 403) {
+    const restriction = await res.clone().json().catch(() => null)
+    if (restriction?.error?.code === 'access_restricted') die(accessRestrictedMessage(restriction))
+  }
+
+  // A blocking notice is a canonical 409 that names itself `action_required`. Unlike a
+  // `meta.notice` on a success, it stands in place of the answer: the server is holding the
+  // result until the person acknowledges the notice, so the CLI reports it, exits unsuccessfully,
+  // and never retries - retrying cannot clear it. Checked ahead of `allow`, like the restriction
+  // above, so a caller that reads its own 409s cannot take this one for an ordinary conflict; a
+  // 409 without this code is left to the handling below, unchanged. The clone leaves the body
+  // readable for those paths.
+  if (res.status === 409) {
+    const blocked = await res.clone().json().catch(() => null)
+    if (blocked?.error?.code === 'action_required') die(actionRequiredMessage(blocked))
+  }
+
   if (allow.includes(res.status)) {
     return {
       status: res.status,
@@ -830,6 +996,10 @@ function cmdLogout() {
     : 'Nobody is signed in here.')
 }
 
+function cmdVersion() {
+  console.log(VERSION)
+}
+
 // ── commands ───────────────────────────────────────────────────────────────
 async function cmdAccountShow() {
   const body = await callCapability('account.status')
@@ -1648,7 +1818,7 @@ function cmdSkill() {
 // Commands that are not something you do to a thing. Signing in is not an operation on a
 // vacancy or a feed, and `intro` is the first thing anyone runs, so it stays one word.
 const PLAIN = {
-  intro: cmdIntro, skill: cmdSkill,
+  intro: cmdIntro, skill: cmdSkill, version: cmdVersion,
   login: cmdLogin, logout: cmdLogout, auth: cmdAuth,
 }
 
@@ -1667,6 +1837,8 @@ const NOUNS = {
 
 const [noun, ...args] = process.argv.slice(2)
 
+await autoUpdate()
+
 if (!noun || noun === '--help' || noun === '-h' || noun === 'help') { console.log(HELP); process.exit(EXIT_OK) }
 
 // `Object.hasOwn`, not a plain lookup: every object inherits `toString` and `constructor`,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hirify-cli",
-  "version": "0.4.2",
+  "version": "0.4.4",
   "description": "Hirify CLI for AI agents: browser sign-in, job feeds, search, reading a vacancy in full, contacts to apply to, and applying on Hirify.",
   "bin": {
     "hirify": "bin/hirify.js"