codex-usage-dashboard 0.1.2 → 0.1.4

package/README.md

@@ -1,121 +1,8 @@
-# Codex Usage Dashboard
+# codex usage
 
-Multi-user Codex usage tracking with a Vercel-hosted dashboard, Supabase Auth, and both direct `npx` connect and website pairing flows.
+i cycle between multiple codex accounts and wanted to keep track of them so i created this
 
-## Stack
+website: https://codexusage.vercel.app
+installation: `npx codex-usage-dashboard@latest connect --site "https://codexusage.vercel.app"`
 
-- Vite + TanStack Router + React Query
-- Supabase Auth + Postgres
-- Vercel Functions for pairing and sync ingest
-- Local Codex access through a bundled `@openai/codex` `app-server`
-
-## What changed
-
-This repo no longer treats the dashboard as a public read-only board.
-
-- Users can start from the website with Google, or from the terminal with a one-line `npx` command.
-- The direct terminal path provisions a dashboard session, opens the browser, and stores the local sync token under `CODEX_HOME`.
-- The website pairing flow is still available and now emits `npx` commands instead of `curl | node`.
-- Vercel receives sync payloads and writes them to Supabase with the service-role key.
-- Row-level security keeps each signed-in user scoped to their own accounts and snapshots.
-
-## Local setup
-
-1. Start Docker Desktop.
-2. Run `npm install`.
-3. Run `npm run setup:local`.
-4. Run `supabase db reset`.
-5. Run `npm run dev`.
-6. Open `http://localhost:5173`.
-
-The Vite dev server now serves the local pairing and sync API routes under `/api/*`.
-
-## Hosted setup
-
-1. Link the repo to a hosted Supabase project with `supabase link --project-ref <ref>`.
-2. Run `npm run setup:hosted`.
-3. Set these Vercel environment variables:
-   - `SUPABASE_URL`
-   - `SUPABASE_SERVICE_ROLE_KEY`
-   - `VITE_SUPABASE_URL`
-   - `VITE_SUPABASE_ANON_KEY`
-4. In Supabase Auth settings, enable `Manual linking` if you want guest dashboard sessions to upgrade into Google later.
-5. If you want the website-first flow, enable the Google provider in Supabase Auth.
-6. Deploy to Vercel.
-
-`npm run setup:hosted` now writes the local env files and pushes any pending hosted Supabase migrations.
-
-## Direct connect flow
-
-Run this on any machine:
-
-```bash
-npx codex-usage-dashboard@latest connect --site "https://your-site.vercel.app"
-```
-
-The package now brings a compatible `@openai/codex` CLI dependency with it, so `connect`, `pair`, and `sync` do not require a separate global Codex install.
-
-If the machine has never logged into Codex before, authenticate once with:
-
-```bash
-npx @openai/codex@latest login
-```
-
-That command:
-
-- starts a local `codex app-server`
-- reads the current Codex account and rate limits
-- provisions a dashboard owner session without requiring Google first
-- opens the hosted dashboard in the browser
-- stores the device token under `CODEX_HOME` in `codex-usage-sync.json`
-- pushes the first snapshot to the dashboard
-
-If the same machine is already connected, rerun the same command to reopen the dashboard and refresh the local snapshot.
-
-## Website pairing flow
-
-1. Sign in on the website.
-2. Click `Create pairing command`.
-3. Run the generated command on the machine you want to pair.
-
-The generated command looks like:
-
-```bash
-npx codex-usage-dashboard@latest pair "https://your-site.vercel.app/api/pair/complete?token=..."
-```
-
-## Live sync after pairing
-
-To keep syncing from that machine:
-
-```bash
-npx codex-usage-dashboard@latest sync --watch
-```
-
-The saved device token is read from the same Codex home that the CLI uses.
-
-## Dev scripts
-
-- `npm run connect -- --site "<site-url>"`: local version of the direct connect command
-- `npm run pair -- "<pair-url>"`: local version of the hosted pairing command
-- `npm run sync -- --watch`: local version of the hosted sync command
-- `npm run collector`: legacy single-operator collector script
-
-## Tario-specific Git workflow for Codex
-
-If the current machine or user context indicates Tario is the operator, treat that as a master-by-default environment.
-
-- Use the local machine identity to decide this.
-- Treat `scutil --get ComputerName` returning `tario` as the primary signal.
-- Treat `/Users/tarioyou` and the local user `tarioyou` as reinforcing signals.
-- In that Tario context, unless otherwise specified, work directly on `master`.
-- If the user explicitly says to work on a branch, create or switch to that branch and work there.
-- Do not create, switch to, or push feature branches by default.
-- Do not default to PR-first workflows or branch-based workflows unless the user asks for them.
-- This rule is specific to Tario's environment; when the operator is not Tario, normal branch workflows remain allowed.
-
-## Notes
-
-- The Vercel API routes live in `api/`.
-- Pairing and device state live in `codex_pairing_sessions` and `codex_devices`.
-- Existing rows without an owner remain in the database but are hidden by RLS from signed-in users.
+![Codex usage](./public/codexusage.png)

package/bin/codex-usage.js

@@ -325,73 +325,71 @@ async function runConnectCommand(args) {
   const codexHome = resolveCodexHome(args.options['codex-home'])
   const existingConfig = await readConfig(codexHome)
   const client = new StdioCodexClient({ codexHome })
+  const siteOriginFromArgs = resolveSiteOrigin(args.options.site)
 
   try {
     await client.connect()
 
     if (existingConfig) {
-      const dashboardUrl = await resolveExistingDashboardUrl(existingConfig, args)
+      try {
+        const dashboardUrl = await resolveExistingDashboardUrl(existingConfig, args)
+        let dashboardOpenState = null
 
-      if (dashboardUrl) {
-        await openDashboard(dashboardUrl)
-      }
+        if (dashboardUrl) {
+          dashboardOpenState = await openDashboard(dashboardUrl)
+        }
 
-      await syncOnce(client, existingConfig, args)
-      console.log('Dashboard opened.')
+        await syncOnce(client, existingConfig, args)
+        logDashboardOpenState(dashboardOpenState)
 
-      if (args.options.watch) {
-        await runWatchLoop(client, existingConfig, args)
-      }
+        if (args.options.watch) {
+          await runWatchLoop(client, existingConfig, args)
+        }
 
-      return
+        return
+      } catch (error) {
+        if (!isRevokedDeviceError(error)) {
+          throw error
+        }
+
+        const siteOrigin =
+          siteOriginFromArgs ??
+          existingConfig.dashboardOrigin ??
+          deriveOriginFromUrl(existingConfig.syncUrl)
+
+        if (!siteOrigin) {
+          throw new Error(
+            `This device was unlinked from the dashboard. Rerun \`${NPX_COMMAND} connect --site "<dashboard-url>"\` to create a new connection.`,
+          )
+        }
+
+        console.log(
+          'This device was unlinked from the dashboard. Creating a new connection...',
+        )
+
+        const refreshedConfig = await startConnectFlow(
+          client,
+          args,
+          codexHome,
+          siteOrigin,
+        )
+
+        if (args.options.watch) {
+          await runWatchLoop(client, refreshedConfig, args)
+        }
+
+        return
+      }
     }
 
-    const siteOrigin = resolveSiteOrigin(args.options.site)
+    const siteOrigin = siteOriginFromArgs
     if (!siteOrigin) {
       throw new Error(
         'Pass --site <url> the first time you run connect, or set CODEX_USAGE_SITE_URL.',
       )
     }
 
-    const snapshot = await readSnapshot(client, true)
-    const device = buildDevicePayload(args, codexHome)
-    const response = await fetch(new URL('/api/connect/start', siteOrigin), {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-      },
-      body: JSON.stringify({
-        accountState: snapshot.accountState,
-        device,
-        rateLimits: snapshot.rateLimits,
-      }),
-    })
-
-    const payload = await parseResponseBody(response)
-    if (!response.ok) {
-      throw new Error(
-        buildHttpErrorMessage(response, payload, 'Unable to connect this machine.'),
-      )
-    }
-
-    const config = {
-      authMode: 'guest-link',
-      codexHome,
-      dashboardOrigin: siteOrigin,
-      deviceId: payload.data.deviceId,
-      deviceToken: payload.data.deviceToken,
-      label: device.label,
-      pollMs: payload.data.pollMs ?? DEFAULT_POLL_MS,
-      syncUrl: payload.data.syncUrl,
-    }
-
-    await writeConfig(codexHome, config)
-    await openDashboard(payload.data.dashboardUrl)
-    console.log('Dashboard opened.')
-    console.log(`Config saved to ${resolveConfigPath(codexHome)}`)
-    console.log(
-      `Next: rerun \`${NPX_COMMAND} connect --site "${siteOrigin}"\` to reopen this dashboard, or \`${NPX_COMMAND} sync --watch\` for live updates only.`,
-    )
+    const config = await startConnectFlow(client, args, codexHome, siteOrigin)
 
     if (args.options.watch) {
       await runWatchLoop(client, config, args)
@@ -401,6 +399,50 @@ async function runConnectCommand(args) {
   }
 }
 
+async function startConnectFlow(client, args, codexHome, siteOrigin) {
+  const snapshot = await readSnapshot(client, true)
+  const device = buildDevicePayload(args, codexHome)
+  const response = await fetch(new URL('/api/connect/start', siteOrigin), {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({
+      accountState: snapshot.accountState,
+      device,
+      rateLimits: snapshot.rateLimits,
+    }),
+  })
+
+  const payload = await parseResponseBody(response)
+  if (!response.ok) {
+    throw new Error(
+      buildHttpErrorMessage(response, payload, 'Unable to connect this machine.'),
+    )
+  }
+
+  const config = {
+    authMode: 'guest-link',
+    codexHome,
+    dashboardOrigin: siteOrigin,
+    deviceId: payload.data.deviceId,
+    deviceToken: payload.data.deviceToken,
+    label: device.label,
+    pollMs: payload.data.pollMs ?? DEFAULT_POLL_MS,
+    syncUrl: payload.data.syncUrl,
+  }
+
+  await writeConfig(codexHome, config)
+  const dashboardOpenState = await openDashboard(payload.data.dashboardUrl)
+  logDashboardOpenState(dashboardOpenState)
+  console.log(`Config saved to ${resolveConfigPath(codexHome)}`)
+  console.log(
+    `Next: rerun \`${NPX_COMMAND} connect --site "${siteOrigin}"\` to reopen this dashboard, or \`${NPX_COMMAND} sync --watch\` for live updates only.`,
+  )
+
+  return config
+}
+
 async function runSyncCommand(args) {
   const codexHome = resolveCodexHome(args.options['codex-home'])
   const config = await readConfig(codexHome)
@@ -575,8 +617,21 @@ function buildDevicePayload(args, codexHome, fallbackLabel) {
 async function openDashboard(url) {
   try {
     await openInBrowser(url)
+    return 'browser'
   } catch {
     console.log(`Open this URL in your browser: ${url}`)
+    return 'manual'
+  }
+}
+
+function logDashboardOpenState(state) {
+  if (state === 'browser') {
+    console.log('Dashboard URL sent to your browser.')
+    return
+  }
+
+  if (state === 'manual') {
+    console.log('Dashboard URL ready.')
   }
 }
 
@@ -620,6 +675,18 @@ function resolveSiteOrigin(configuredValue) {
   return new URL(value).origin
 }
 
+function deriveOriginFromUrl(value) {
+  if (typeof value !== 'string' || !value) {
+    return null
+  }
+
+  try {
+    return new URL(value).origin
+  } catch {
+    return null
+  }
+}
+
 function resolveCodexHome(configuredValue) {
   const home = configuredValue ?? process.env.CODEX_HOME ?? path.join(os.homedir(), '.codex')
 
@@ -826,7 +893,52 @@ async function readConfig(codexHome) {
     return null
   }
 
-  return JSON.parse(await readFile(configPath, 'utf8'))
+  const rawConfig = JSON.parse(await readFile(configPath, 'utf8'))
+  const normalizedConfig = normalizeConfig(rawConfig)
+
+  if (JSON.stringify(normalizedConfig) !== JSON.stringify(rawConfig)) {
+    await writeConfig(codexHome, normalizedConfig)
+  }
+
+  return normalizedConfig
+}
+
+function normalizeConfig(config) {
+  if (!config || typeof config !== 'object') {
+    return config
+  }
+
+  const normalizedConfig = { ...config }
+
+  if (
+    !normalizedConfig.dashboardOrigin &&
+    typeof normalizedConfig.syncUrl === 'string'
+  ) {
+    try {
+      normalizedConfig.dashboardOrigin = new URL(
+        normalizedConfig.syncUrl,
+      ).origin
+    } catch {
+      // Leave the saved origin untouched when the sync URL is malformed.
+    }
+  }
+
+  if (looksLikeLegacyGuestLinkConfig(config)) {
+    normalizedConfig.authMode = 'guest-link'
+  }
+
+  return normalizedConfig
+}
+
+function looksLikeLegacyGuestLinkConfig(config) {
+  return (
+    !config.authMode &&
+    !config.dashboardOrigin &&
+    typeof config.deviceToken === 'string' &&
+    config.deviceToken.length > 0 &&
+    typeof config.syncUrl === 'string' &&
+    config.syncUrl.length > 0
+  )
 }
 
 async function parseResponseBody(response) {
@@ -876,6 +988,13 @@ function buildHttpErrorMessage(response, payload, fallbackMessage) {
   return appendHttpContext(message, vercelError, vercelId)
 }
 
+function isRevokedDeviceError(error) {
+  return (
+    error instanceof Error &&
+    error.message.includes('This device is no longer authorized.')
+  )
+}
+
 function appendHttpContext(message, vercelError, vercelId) {
   const context = []
 

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "codex-usage-dashboard",
   "private": false,
-  "version": "0.1.2",
+  "version": "0.1.4",
   "files": [
     "README.md",
     "bin"
   ],
   "type": "module",
   "bin": {
-    "codex-usage": "./bin/codex-usage.js",
-    "codex-usage-dashboard": "./bin/codex-usage.js"
+    "codex-usage": "bin/codex-usage.js",
+    "codex-usage-dashboard": "bin/codex-usage.js"
   },
   "scripts": {
     "dev": "vite",
@@ -23,45 +23,47 @@
     "setup:hosted": "tsx scripts/setup-hosted.ts",
     "setup:local": "tsx scripts/setup-local.ts",
     "collector": "tsx scripts/codex-collector.ts",
-    "collector:once": "tsx scripts/codex-collector.ts --once"
+    "collector:once": "tsx scripts/codex-collector.ts --once",
+    "release:check": "node ./scripts/check-publish.mjs",
+    "prepublishOnly": "npm run release:check"
   },
   "dependencies": {
+    "@openai/codex": "^0.118.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.39.4",
     "@fontsource-variable/geist": "^5.2.8",
-    "@openai/codex": "^0.118.0",
     "@radix-ui/react-slot": "^1.2.4",
+    "@tailwindcss/vite": "^4.2.2",
     "@supabase/supabase-js": "^2.101.1",
     "@tanstack/react-query": "^5.96.2",
     "@tanstack/react-query-devtools": "^5.96.2",
     "@tanstack/react-router": "^1.168.10",
+    "@tanstack/router-plugin": "^1.167.12",
     "@tanstack/router-devtools": "^1.166.11",
+    "@types/node": "^24.12.0",
+    "@types/react": "^19.2.14",
+    "@types/react-dom": "^19.2.3",
+    "@vitejs/plugin-react": "^6.0.1",
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",
     "dotenv": "^17.4.1",
+    "eslint": "^9.39.4",
+    "eslint-plugin-react-hooks": "^7.0.1",
+    "eslint-plugin-react-refresh": "^0.5.2",
+    "globals": "^17.4.0",
     "lucide-react": "^1.7.0",
     "radix-ui": "^1.4.3",
     "react": "^19.2.4",
     "react-dom": "^19.2.4",
     "shadcn": "^4.1.2",
+    "tailwindcss": "^4.2.2",
     "tailwind-merge": "^3.5.0",
     "tw-animate-css": "^1.4.0",
-    "zod": "^4.3.6"
-  },
-  "devDependencies": {
-    "@eslint/js": "^9.39.4",
-    "@tailwindcss/vite": "^4.2.2",
-    "@tanstack/router-plugin": "^1.167.12",
-    "@types/node": "^24.12.0",
-    "@types/react": "^19.2.14",
-    "@types/react-dom": "^19.2.3",
-    "@vitejs/plugin-react": "^6.0.1",
-    "eslint": "^9.39.4",
-    "eslint-plugin-react-hooks": "^7.0.1",
-    "eslint-plugin-react-refresh": "^0.5.2",
-    "globals": "^17.4.0",
-    "tailwindcss": "^4.2.2",
     "tsx": "^4.21.0",
     "typescript": "~5.9.3",
     "typescript-eslint": "^8.57.0",
-    "vite": "^8.0.1"
+    "vite": "^8.0.1",
+    "zod": "^4.3.6"
   }
 }