mohdel 3.6.0 → 3.6.1

package/README.md

@@ -42,7 +42,10 @@ Use `mo chatgpt list`, `select <account-id>`, `login --new`, and
 data directory (`~/.local/share/mohdel/chatgpt/` on Linux), with owner-only
 files and serialized token refresh. They are separate from the catalog.
 `mo chatgpt login <account-id>` reuses a saved registration after sign-out
-or a failed code exchange. If a crashed process leaves `accounts.lock`,
+or a failed code exchange. ChatGPT lists each registration by name: a new one
+is `Mohdel (<hostname>)`, or the label from `mo chatgpt login --name <label>`
+if you'd rather not send the hostname. The name is fixed when the registration
+is made, and `mo chatgpt list` shows it next to the account id. If a crashed process leaves `accounts.lock`,
 confirm its recorded PID has exited before removing that lock.
 
 This OpenAI flow is intended for open-source and personal local tools;

package/js/chatgpt/index.js

@@ -1,5 +1,6 @@
 import { randomBytes, createHash } from 'node:crypto'
 import { createServer } from 'node:http'
+import { hostname } from 'node:os'
 import { createRemoteJWKSet, jwtVerify } from 'jose'
 import { defaultDirectory, readStore, withStore } from './store.js'
 import { discoverModels, visibleModels } from './models.js'
@@ -12,6 +13,8 @@ const SCOPE = `openid profile email offline_access resource.invoke ${PERMISSION}
 const jwks = createRemoteJWKSet(new URL(`${ISSUER}/.well-known/jwks.json`))
 const random = () => randomBytes(32).toString('base64url')
 const REFRESH_MARGIN = 30000
+// Every registration made before names were stored was sent this hint.
+const UNNAMED_REGISTRATION = 'Mohdel'
 export const usageURL = 'https://chatgpt.com/settings/usage'
 
 async function jsonRequest (fetcher, url, options = {}) {
@@ -61,6 +64,7 @@ function credentials (tokens, previous = {}) {
 
 const summary = (id, account, active) => ({
   id,
+  name: account.name ?? UNNAMED_REGISTRATION,
   email: account.email ?? null,
   active: id === active,
   connected: !!account.access_token,
@@ -116,7 +120,7 @@ export function createChatGPT (options = {}) {
     return visibleModels(await discoverModels(accessToken, { fetch: fetcher }))
   }
 
-  /** @param {string} [id] @returns {Promise<{revoked: boolean}>} */
+  /** @param {string} [id] @returns {Promise<{revoked: boolean, name: string}>} */
   const logout = async (id) => withStore(directory, async (store, save) => {
     id ??= store.active
     const account = store.accounts[id]
@@ -141,16 +145,25 @@ export function createChatGPT (options = {}) {
     for (const key of ['access_token', 'refresh_token', 'id_token', 'expires_at', 'scopes']) delete account[key]
     if (store.active === id) store.active = null
     await save(store)
-    return { revoked }
+    return { revoked, name: account.name ?? UNNAMED_REGISTRATION }
   })
 
-  /** @param {{ authorize: (url: string) => any, accountId?: string, timeoutMs?: number }} settings */
-  const login = async ({ authorize, accountId, timeoutMs = 300000 }) => {
+  /**
+   * `name` labels a new registration on the ChatGPT side (default `Mohdel (<hostname>)`);
+   * an existing registration keeps the name it was created with.
+   * @param {{ authorize: (url: string) => any, accountId?: string, name?: string, timeoutMs?: number }} settings
+   */
+  const login = async ({ authorize, accountId, name, timeoutMs = 300000 }) => {
+    if (name !== undefined && (typeof name !== 'string' || !name.trim())) throw new Error('ChatGPT registration name must not be empty')
     const initial = await withStore(directory, async (store, save) => {
       if (accountId && !store.accounts[accountId]) throw new Error('Unknown ChatGPT account')
+      if (name !== undefined && store.accounts[accountId]) {
+        throw new Error('A ChatGPT registration keeps the name it was created with; start a new registration to use another name')
+      }
       await save(store)
       return { host: store.host, account: store.accounts[accountId] }
     })
+    const label = name ?? `Mohdel (${hostname()})`
     const state = random()
     const nonce = random()
     const verifier = random()
@@ -193,7 +206,7 @@ export function createChatGPT (options = {}) {
       code_challenge_method: 'S256',
       code_challenge: createHash('sha256').update(verifier).digest('base64url')
     }).toString()
-    if (!initial.account) url.searchParams.set('agent_name_hint', 'Mohdel')
+    if (!initial.account) url.searchParams.set('agent_name_hint', label)
     if (initial.account?.id_token) url.searchParams.set('id_token_hint', initial.account.id_token)
     const timer = setTimeout(() => fail(new Error('ChatGPT sign-in timed out')), timeoutMs)
     try {
@@ -205,7 +218,7 @@ export function createChatGPT (options = {}) {
       }
       // Keep the issued ID even if code exchange fails; it must not be registered again.
       await withStore(directory, async (store, save) => {
-        store.accounts[clientId] ??= { client_id: clientId }
+        store.accounts[clientId] ??= { client_id: clientId, name: label }
         await save(store)
       })
       const tokens = await tokenRequest({ grant_type: 'authorization_code', client_id: clientId, code: params.get('code'), code_verifier: verifier, redirect_uri: redirect })
@@ -213,7 +226,7 @@ export function createChatGPT (options = {}) {
       return await withStore(directory, async (store, save) => {
         const previous = store.accounts[clientId]
         if (previous.subject && previous.subject !== identity.sub) throw new Error('ChatGPT returned a different account identity')
-        const account = { ...credentials(tokens), client_id: clientId, subject: identity.sub, email: identity.email ?? null }
+        const account = { ...credentials(tokens), client_id: clientId, name: previous.name, subject: identity.sub, email: identity.email ?? null }
         store.accounts[clientId] = account
         store.active = clientId
         await save(store)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mohdel",
-  "version": "3.6.0",
+  "version": "3.6.1",
   "license": "MIT",
   "author": {
     "name": "Christophe Le Bars",
@@ -144,7 +144,7 @@
     "@opentelemetry/exporter-trace-otlp-grpc": "^0.222.0",
     "@opentelemetry/sdk-node": "^0.222.0",
     "chalk": "^6.0.1",
-    "mohdel-thin-gate-linux-x64-gnu": "3.6.0"
+    "mohdel-thin-gate-linux-x64-gnu": "3.6.1"
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.129.0",

package/src/cli/chatgpt.js

@@ -3,18 +3,23 @@ import { parseJsonFlag, printAvailableFields, jsonOutput } from './json-output.j
 
 export async function runChatGPT (args) {
   const output = parseJsonFlag(args)
+  const nameAt = args.indexOf('--name')
+  const name = nameAt === -1 ? undefined : args.splice(nameAt, 2)[1]
   const [verb, id] = args
   const auth = createChatGPT()
   try {
+    if (nameAt !== -1 && (verb !== 'login' || !name || name.startsWith('--'))) {
+      throw new Error('Usage: mo chatgpt login --name <label>')
+    }
     if (verb === 'list' || verb === 'models') {
-      const fields = verb === 'list' ? ['id', 'email', 'active', 'connected', 'planUsage'] : ['id', 'model', 'label']
+      const fields = verb === 'list' ? ['id', 'name', 'email', 'active', 'connected', 'planUsage'] : ['id', 'model', 'label']
       if (output.json && !output.fields) { printAvailableFields(fields); return }
       const items = verb === 'list' ? await auth.accounts() : await auth.models(id)
       if (output.json) jsonOutput(items, output.fields)
       else {
         for (const item of items) {
           console.log(verb === 'list'
-            ? `${item.active ? '*' : ' '} ${item.id}  ${item.email ?? ''}  ${item.planUsage ? 'Using ChatGPT plan' : item.connected ? 'Plan usage not enabled' : 'Signed out'}`
+            ? `${item.active ? '*' : ' '} ${item.id}  ${item.name}  ${item.email ?? ''}  ${item.planUsage ? 'Using ChatGPT plan' : item.connected ? 'Plan usage not enabled' : 'Signed out'}`
             : `${item.id}  ${item.label}`)
         }
       }
@@ -23,7 +28,8 @@ export async function runChatGPT (args) {
     if (verb === 'login') {
       const active = (await auth.accounts()).find(a => a.active)
       const account = await auth.login({
-        accountId: id === '--new' ? undefined : id ?? active?.id,
+        accountId: id === '--new' || (name && !id) ? undefined : id ?? active?.id,
+        name,
         authorize: value => {
           // Retained ID-token hints must never be printed to a terminal or log.
           const url = new URL(value)
@@ -31,22 +37,24 @@ export async function runChatGPT (args) {
           console.log(`Continue with ChatGPT — open this URL in your browser:\n${url}`)
         }
       })
-      console.log(`Connected: ${account.id} ${account.email ?? ''}`)
+      console.log(`Connected: ${account.id} ${account.name} ${account.email ?? ''}`)
       console.log(account.planUsage ? 'Using ChatGPT plan. Discover models: mo chatgpt models' : 'Plan usage not enabled. Run mo chatgpt login to grant access.')
       console.log(`Manage usage: ${usageURL}`)
     } else if (verb === 'select' && id) {
       await auth.select(id)
       console.log(`Selected ChatGPT account: ${id}`)
     } else if (verb === 'logout') {
-      const { revoked } = await auth.logout(id)
+      const { revoked, name: registration } = await auth.logout(id)
       console.log('Signed out locally.')
-      if (!revoked) console.log(`Remote revocation was not confirmed. Disconnect Mohdel in ChatGPT Settings: ${usageURL}`)
+      if (!revoked) console.log(`Remote revocation was not confirmed. Disconnect "${registration}" in ChatGPT Settings: ${usageURL}`)
     } else if (verb === 'usage') {
       console.log(usageURL)
     } else {
       console.log(`mo chatgpt — use your eligible ChatGPT plan
 
   login [account-id|--new]   Continue with ChatGPT in your browser
+  login --name <label>       Start a new registration, named as ChatGPT shows it
+                             (a new registration defaults to Mohdel (<hostname>))
   list [--json fields]      Saved accounts and the active account
   select <account-id>       Choose a saved account
   logout [account-id]       Revoke and clear its local credentials

package/src/cli/index.js

@@ -9,6 +9,7 @@
  * Aliases: ls → model list, rl → ratelimit
  */
 
+import { createRequire } from 'node:module'
 import { detectAssistants, launchLines } from '../lib/assistants.js'
 import { getConfig } from '../lib/common.js'
 import { ALIASES } from './aliases.js'
@@ -34,6 +35,11 @@ if (command === 'completion') {
   process.exit(0)
 }
 
+if (command === '--version') {
+  console.log(createRequire(import.meta.url)('../../package.json').version)
+  process.exit(0)
+}
+
 if (command === '-h' || command === '--help') {
   const assistant = (await getConfig()).assistant || null
   const { default: PROVIDER_INFO } = await import('../lib/provider-info.js')
@@ -92,6 +98,7 @@ Commands:
   default [model]                         Set the model "mo ask" uses by default
   doctor                                  Check that your install is wired up
   completion bash                         Shell completion — source <(mo completion bash)
+  --version                               Print the installed mohdel version
 
 Catalog work with a coding agent:
   Prices, context limits and cache rates are in no provider API — they live on