@wavyx/pdcli 0.1.0 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wavyx/pdcli",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "publishConfig": {
     "access": "public"
   },
@@ -100,6 +100,9 @@
     "cli-table3": "0.6.5",
     "conf": "15.1.0",
     "debug": "4.4.3",
+    "js-yaml": "^4.1.1",
+    "node-jq": "^6.3.1",
+    "open": "^11.0.0",
     "ora": "9.4.0",
     "undici": "8.3.0"
   },

package/src/base-command.js

@@ -1,7 +1,8 @@
 import { Command, Flags } from '@oclif/core'
 import { formatOutput } from './lib/output/index.js'
 import { loadConfig } from './lib/config.js'
-import { resolveCredentials } from './lib/auth.js'
+import { resolveCredentials, refreshAccessToken } from './lib/auth.js'
+import { setOAuthTokens } from './lib/keychain.js'
 import { createClient } from './lib/client.js'
 import { handleError } from './lib/errors.js'
 
@@ -11,7 +12,15 @@ export default class BaseCommand extends Command {
       char: 'o',
       description: 'Output format',
       helpGroup: 'GLOBAL',
-      options: ['table', 'json'],
+      options: ['table', 'json', 'yaml', 'csv'],
+    }),
+    jq: Flags.string({
+      description: 'jq expression to filter JSON output',
+      helpGroup: 'GLOBAL',
+    }),
+    fields: Flags.string({
+      description: 'Comma-separated fields to display',
+      helpGroup: 'GLOBAL',
     }),
     profile: Flags.string({
       description: 'Named auth profile to use',
@@ -67,16 +76,45 @@ export default class BaseCommand extends Command {
 
     if (this.constructor.skipAuth) return
 
-    const { companyDomain, token } = await resolveCredentials({
+    const creds = await resolveCredentials({
       flags,
       profile: this.activeProfile,
     })
-    this.apiClient = createClient({
-      companyDomain,
-      token,
+
+    const common = {
       retry: !flags['no-retry'],
       timeout: flags.timeout,
       userAgent: `pdcli/${this.config.version}`,
+    }
+
+    if (creds.mode === 'oauth') {
+      this.apiClient = createClient({
+        ...common,
+        apiDomain: creds.apiDomain,
+        token: creds.token,
+        authMode: 'oauth',
+        onRefresh: async () => {
+          const refreshed = await refreshAccessToken({
+            refreshToken: creds.oauth.refreshToken,
+            clientId: creds.oauth.clientId,
+            clientSecret: creds.oauth.clientSecret,
+          })
+          await setOAuthTokens(this.activeProfile, {
+            ...creds.oauth,
+            accessToken: refreshed.accessToken,
+            refreshToken: refreshed.refreshToken,
+            expiresAt: Date.now() + refreshed.expiresIn * 1000,
+          })
+          return refreshed.accessToken
+        },
+      })
+      return
+    }
+
+    this.apiClient = createClient({
+      ...common,
+      companyDomain: creds.companyDomain,
+      token: creds.token,
     })
   }
 
@@ -90,7 +128,27 @@ export default class BaseCommand extends Command {
    * @param {Record<string, import('./lib/output/table.js').Column>} columns
    */
   async outputResults(data, columns) {
-    formatOutput(data, columns, this.resolveFormat(), this)
+    if (this.flags.jq) {
+      // node-jq ships a native binary — load it only when actually used.
+      const { run } = await import('node-jq')
+      const input = JSON.stringify(Array.isArray(data) ? data : [data])
+      const result = await run(this.flags.jq, input, {
+        input: 'string',
+        output: 'pretty',
+      })
+      this.log(result)
+      return
+    }
+
+    let filteredColumns = columns
+    if (this.flags.fields && columns) {
+      const requested = this.flags.fields.split(',').map((f) => f.trim())
+      filteredColumns = Object.fromEntries(
+        Object.entries(columns).filter(([key]) => requested.includes(key)),
+      )
+    }
+
+    formatOutput(data, filteredColumns, this.resolveFormat(), this)
   }
 
   async catch(err) {

package/src/commands/activity/create.js

@@ -0,0 +1,63 @@
+import { Flags } from '@oclif/core'
+import BaseCommand from '../../base-command.js'
+import { buildWriteBody } from '../../lib/input.js'
+import { defsForFields, outputRecord } from '../../lib/entity-view.js'
+
+export default class ActivityCreateCommand extends BaseCommand {
+  static description = 'Create an activity'
+
+  static examples = [
+    '<%= config.bin %> activity create --subject "Demo call" --type call --due-date 2026-06-10',
+    '<%= config.bin %> activity create --subject "Follow up" --field "Outcome=Positive"',
+    '<%= config.bin %> activity create --subject "Raw" --body \'{"priority":5}\'',
+  ]
+
+  static flags = {
+    ...BaseCommand.baseFlags,
+    subject: Flags.string({ required: true, description: 'Activity subject' }),
+    type: Flags.string({ default: 'task', description: 'Activity type' }),
+    'due-date': Flags.string({ description: 'Due date (YYYY-MM-DD)' }),
+    'due-time': Flags.string({ description: 'Due time (HH:MM)' }),
+    duration: Flags.string({ description: 'Duration (HH:MM)' }),
+    deal: Flags.integer({ description: 'Linked deal ID' }),
+    person: Flags.integer({ description: 'Linked person ID' }),
+    org: Flags.integer({ description: 'Linked organization ID' }),
+    owner: Flags.integer({ description: 'Owner (user) ID' }),
+    note: Flags.string({ description: 'Activity note' }),
+    done: Flags.boolean({ description: 'Mark the activity as done' }),
+    field: Flags.string({
+      multiple: true,
+      description: 'Custom/standard field as "Name=Value" (repeatable)',
+    }),
+    body: Flags.string({ description: 'Raw JSON body to merge (flags win)' }),
+  }
+
+  async run() {
+    const { flags } = await this.parse(ActivityCreateCommand)
+
+    const body = buildWriteBody({
+      typed: {
+        subject: flags.subject,
+        type: flags.type,
+        due_date: flags['due-date'],
+        due_time: flags['due-time'],
+        duration: flags.duration,
+        deal_id: flags.deal,
+        participants:
+          flags.person != null
+            ? [{ person_id: flags.person, primary: true }]
+            : undefined,
+        org_id: flags.org,
+        owner_id: flags.owner,
+        note: flags.note,
+        done: flags.done ? true : undefined,
+      },
+      fields: flags.field,
+      rawBody: flags.body,
+      defs: await defsForFields(this, 'activity', flags.field),
+    })
+
+    const res = await this.apiClient.post('/api/v2/activities', { body })
+    await outputRecord(this, res.data, 'activity')
+  }
+}

package/src/commands/activity/delete.js

@@ -0,0 +1,39 @@
+import { Args, Flags } from '@oclif/core'
+import chalk from 'chalk'
+import BaseCommand from '../../base-command.js'
+import { confirmAction } from '../../lib/confirm.js'
+import { CliError } from '../../lib/errors.js'
+
+export default class ActivityDeleteCommand extends BaseCommand {
+  static description = 'Delete an activity'
+
+  static examples = [
+    '<%= config.bin %> activity delete 9',
+    '<%= config.bin %> activity delete 9 --yes',
+  ]
+
+  static args = {
+    id: Args.integer({ required: true, description: 'Activity ID' }),
+  }
+
+  static flags = {
+    ...BaseCommand.baseFlags,
+    yes: Flags.boolean({
+      char: 'y',
+      description: 'Skip the confirmation prompt',
+      default: false,
+    }),
+  }
+
+  async run() {
+    const { args, flags } = await this.parse(ActivityDeleteCommand)
+
+    const ok = await confirmAction(`Delete activity ${args.id}?`, flags.yes)
+    if (!ok) {
+      throw new CliError('Aborted', { exitCode: 1 })
+    }
+
+    await this.apiClient.del(`/api/v2/activities/${args.id}`)
+    this.log(chalk.green(`Deleted activity ${args.id}`))
+  }
+}

package/src/commands/activity/get.js

@@ -1,7 +1,6 @@
 import { Args } from '@oclif/core'
 import BaseCommand from '../../base-command.js'
-import { getFields, makeResolver } from '../../lib/fields.js'
-import { flattenRecord } from '../../lib/output/record.js'
+import { outputRecord } from '../../lib/entity-view.js'
 
 export default class ActivityGetCommand extends BaseCommand {
   static description = 'Get an activity by ID'
@@ -22,20 +21,6 @@ export default class ActivityGetCommand extends BaseCommand {
   async run() {
     const { args } = await this.parse(ActivityGetCommand)
     const body = await this.apiClient.get(`/api/v2/activities/${args.id}`)
-    let record = body.data
-
-    if (this.resolveFormat() === 'table') {
-      if (record.custom_fields && Object.keys(record.custom_fields).length) {
-        const defs = await getFields(this.apiClient, 'activity')
-        record = makeResolver(defs).resolveCustomFields(record)
-      }
-      await this.outputResults(flattenRecord(record), {
-        field: { header: 'Field' },
-        value: { header: 'Value' },
-      })
-      return
-    }
-
-    await this.outputResults(record, {})
+    await outputRecord(this, body.data, 'activity')
   }
 }

package/src/commands/activity/update.js

@@ -0,0 +1,89 @@
+import { Args, Flags } from '@oclif/core'
+import BaseCommand from '../../base-command.js'
+import { buildWriteBody } from '../../lib/input.js'
+import { defsForFields, outputRecord } from '../../lib/entity-view.js'
+import { CliError } from '../../lib/errors.js'
+
+export default class ActivityUpdateCommand extends BaseCommand {
+  static description =
+    'Update an activity (v2 PATCH — only provided fields change)'
+
+  static examples = [
+    '<%= config.bin %> activity update 9 --subject "Renamed"',
+    '<%= config.bin %> activity update 9 --done',
+    '<%= config.bin %> activity update 9 --field "Outcome=Positive"',
+  ]
+
+  static args = {
+    id: Args.integer({ required: true, description: 'Activity ID' }),
+  }
+
+  static flags = {
+    ...BaseCommand.baseFlags,
+    subject: Flags.string({ description: 'Activity subject' }),
+    type: Flags.string({ description: 'Activity type' }),
+    'due-date': Flags.string({ description: 'Due date (YYYY-MM-DD)' }),
+    'due-time': Flags.string({ description: 'Due time (HH:MM)' }),
+    duration: Flags.string({ description: 'Duration (HH:MM)' }),
+    deal: Flags.integer({ description: 'Linked deal ID' }),
+    person: Flags.integer({ description: 'Linked person ID' }),
+    org: Flags.integer({ description: 'Linked organization ID' }),
+    owner: Flags.integer({ description: 'Owner (user) ID' }),
+    note: Flags.string({ description: 'Activity note' }),
+    done: Flags.boolean({
+      description: 'Mark the activity as done',
+      exclusive: ['undone'],
+    }),
+    undone: Flags.boolean({
+      description: 'Mark the activity as not done',
+      exclusive: ['done'],
+    }),
+    field: Flags.string({
+      multiple: true,
+      description: 'Custom/standard field as "Name=Value" (repeatable)',
+    }),
+    body: Flags.string({ description: 'Raw JSON body to merge (flags win)' }),
+  }
+
+  async run() {
+    const { args, flags } = await this.parse(ActivityUpdateCommand)
+
+    let done
+    if (flags.done) done = true
+    else if (flags.undone) done = false
+
+    const body = buildWriteBody({
+      typed: {
+        subject: flags.subject,
+        type: flags.type,
+        due_date: flags['due-date'],
+        due_time: flags['due-time'],
+        duration: flags.duration,
+        deal_id: flags.deal,
+        participants:
+          flags.person != null
+            ? [{ person_id: flags.person, primary: true }]
+            : undefined,
+        org_id: flags.org,
+        owner_id: flags.owner,
+        note: flags.note,
+        done,
+      },
+      fields: flags.field,
+      rawBody: flags.body,
+      defs: await defsForFields(this, 'activity', flags.field),
+    })
+
+    if (Object.keys(body).length === 0) {
+      throw new CliError(
+        'Nothing to update — pass at least one field flag, --field, or --body',
+        { exitCode: 64 },
+      )
+    }
+
+    const res = await this.apiClient.patch(`/api/v2/activities/${args.id}`, {
+      body,
+    })
+    await outputRecord(this, res.data, 'activity')
+  }
+}

package/src/commands/api.js

@@ -53,8 +53,12 @@ export default class ApiCommand extends BaseCommand {
 
     const data = await this.apiClient[method](args.path, opts)
 
-    if (data !== null) {
-      this.log(JSON.stringify(data, null, 2))
+    if (data === null) return
+
+    if (this.flags.jq) {
+      await this.outputResults(data, {})
+      return
     }
+    this.log(JSON.stringify(data, null, 2))
   }
 }

package/src/commands/auth/login.js

@@ -3,21 +3,26 @@ import { input, password } from '@inquirer/prompts'
 import chalk from 'chalk'
 import ora from 'ora'
 import BaseCommand from '../../base-command.js'
-import { normalizeCompanyDomain, validateToken } from '../../lib/auth.js'
+import {
+  authorizationCodeFlow,
+  normalizeCompanyDomain,
+  validateToken,
+} from '../../lib/auth.js'
 import { createClient } from '../../lib/client.js'
-import { setToken } from '../../lib/keychain.js'
+import { setToken, setOAuthTokens } from '../../lib/keychain.js'
 import { setProfileConfig } from '../../lib/config.js'
 
 export default class LoginCommand extends BaseCommand {
   static skipAuth = true
 
   static description =
-    'Authenticate with Pipedrive using your personal API token'
+    'Authenticate with Pipedrive (personal API token, or OAuth with --oauth)'
 
   static examples = [
     '<%= config.bin %> auth login',
     '<%= config.bin %> auth login --company acme --api-token <token>',
-    '<%= config.bin %> auth login --profile work',
+    '<%= config.bin %> auth login --oauth',
+    '<%= config.bin %> auth login --oauth --client-id <id> --client-secret <secret>',
   ]
 
   static flags = {
@@ -30,11 +35,39 @@ export default class LoginCommand extends BaseCommand {
       description:
         'Personal API token (app.pipedrive.com/settings/api). Prefer the prompt or env so the token stays out of shell history',
     }),
+    oauth: Flags.boolean({
+      description:
+        'Use OAuth 2.0 via your own Developer Hub app (browser flow)',
+      default: false,
+    }),
+    'client-id': Flags.string({
+      description: 'OAuth app client ID (--oauth; env PDCLI_CLIENT_ID)',
+      dependsOn: ['oauth'],
+    }),
+    'client-secret': Flags.string({
+      description: 'OAuth app client secret (--oauth; env PDCLI_CLIENT_SECRET)',
+      dependsOn: ['oauth'],
+    }),
+    port: Flags.integer({
+      description:
+        "OAuth callback port — must match the app's registered callback URL (--oauth)",
+      default: 9999,
+      dependsOn: ['oauth'],
+    }),
   }
 
   async run() {
     const { flags } = await this.parse(LoginCommand)
 
+    if (flags.oauth) {
+      await this.#oauthLogin(flags)
+      return
+    }
+
+    await this.#tokenLogin(flags)
+  }
+
+  async #tokenLogin(flags) {
     const rawDomain =
       flags.company ??
       (await input({
@@ -58,15 +91,14 @@ export default class LoginCommand extends BaseCommand {
         userAgent: `pdcli/${this.config.version}`,
       })
       user = await validateToken(client)
+    } finally {
       spinner.stop()
-    } catch (err) {
-      spinner.stop()
-      throw err
     }
 
     // Token only ever goes to the OS keychain; the domain lives in config.
     await setToken(this.activeProfile, token)
     setProfileConfig(this.activeProfile, 'company_domain', companyDomain)
+    setProfileConfig(this.activeProfile, 'auth_mode', 'token')
 
     this.log(
       chalk.green(
@@ -76,4 +108,67 @@ export default class LoginCommand extends BaseCommand {
     )
     this.log(chalk.dim(`Profile: ${this.activeProfile} — token in keychain`))
   }
+
+  async #oauthLogin(flags) {
+    const clientId =
+      flags['client-id'] ??
+      process.env.PDCLI_CLIENT_ID ??
+      (await input({
+        message: 'OAuth client ID (Developer Hub app):',
+      }))
+    const clientSecret =
+      flags['client-secret'] ??
+      process.env.PDCLI_CLIENT_SECRET ??
+      (await password({
+        message: 'OAuth client secret:',
+        mask: true,
+      }))
+
+    this.log('Opening your browser to authorize pdcli...')
+    const tokens = await authorizationCodeFlow({
+      clientId,
+      clientSecret,
+      port: flags.port,
+    })
+
+    const spinner = ora('Validating access token...').start()
+    let user
+    try {
+      const client = createClient({
+        apiDomain: tokens.apiDomain,
+        token: tokens.accessToken,
+        authMode: 'oauth',
+        userAgent: `pdcli/${this.config.version}`,
+      })
+      user = await validateToken(client)
+    } finally {
+      spinner.stop()
+    }
+
+    // The whole bundle — including the client secret — lives in the
+    // keychain. Config only records the mode and display domain.
+    await setOAuthTokens(this.activeProfile, {
+      accessToken: tokens.accessToken,
+      refreshToken: tokens.refreshToken,
+      expiresAt: Date.now() + tokens.expiresIn * 1000,
+      apiDomain: tokens.apiDomain,
+      clientId,
+      clientSecret,
+    })
+    const companyDomain = normalizeCompanyDomain(tokens.apiDomain)
+    setProfileConfig(this.activeProfile, 'auth_mode', 'oauth')
+    setProfileConfig(this.activeProfile, 'company_domain', companyDomain)
+
+    this.log(
+      chalk.green(
+        `Logged in via OAuth to ${chalk.cyan(tokens.apiDomain)} ` +
+          `as ${chalk.bold(user.name)} (${user.email})`,
+      ),
+    )
+    this.log(
+      chalk.dim(
+        `Profile: ${this.activeProfile} — tokens in keychain, auto-refresh on expiry`,
+      ),
+    )
+  }
 }

package/src/commands/auth/logout.js

@@ -1,6 +1,6 @@
 import chalk from 'chalk'
 import BaseCommand from '../../base-command.js'
-import { deleteToken } from '../../lib/keychain.js'
+import { deleteToken, deleteOAuthTokens } from '../../lib/keychain.js'
 
 export default class LogoutCommand extends BaseCommand {
   static skipAuth = true
@@ -17,6 +17,7 @@ export default class LogoutCommand extends BaseCommand {
     await this.parse(LogoutCommand)
 
     await deleteToken(this.activeProfile)
+    await deleteOAuthTokens(this.activeProfile)
     this.log(
       chalk.green(`Logged out of profile ${chalk.cyan(this.activeProfile)}`),
     )

package/src/commands/auth/status.js

@@ -1,6 +1,10 @@
 import chalk from 'chalk'
 import BaseCommand from '../../base-command.js'
-import { getToken, isKeychainAvailable } from '../../lib/keychain.js'
+import {
+  getToken,
+  getOAuthTokens,
+  isKeychainAvailable,
+} from '../../lib/keychain.js'
 import { getProfileConfig } from '../../lib/config.js'
 import { companyDomainToBaseOrigin, validateToken } from '../../lib/auth.js'
 import { createClient } from '../../lib/client.js'
@@ -20,17 +24,24 @@ export default class StatusCommand extends BaseCommand {
     await this.parse(StatusCommand)
 
     const domain = getProfileConfig(this.activeProfile, 'company_domain')
-    const token = await getToken(this.activeProfile)
+    const authMode = getProfileConfig(this.activeProfile, 'auth_mode')
     const keychainType = isKeychainAvailable() ? 'OS keychain' : 'unavailable'
 
     this.log(chalk.bold('Auth Status'))
     this.log('')
     this.log(`  Profile:    ${chalk.cyan(this.activeProfile)}`)
     this.log(`  Keychain:   ${keychainType}`)
+
+    if (authMode === 'oauth') {
+      await this.#oauthStatus()
+      return
+    }
+
     this.log(
       `  API host:   ${domain ? companyDomainToBaseOrigin(domain) : chalk.dim('(not set)')}`,
     )
 
+    const token = await getToken(this.activeProfile)
     if (!token) {
       this.log(`  Status:     ${chalk.red('Not authenticated')}`)
       this.log('')
@@ -42,21 +53,58 @@ export default class StatusCommand extends BaseCommand {
 
     // Best-effort identity check — network errors are not fatal here.
     if (domain) {
-      try {
-        const client = createClient({
+      await this.#showIdentity(
+        createClient({
           companyDomain: domain,
           token,
           retry: false,
           userAgent: `pdcli/${this.config.version}`,
-        })
-        const user = await validateToken(client)
-        this.log('')
-        this.log(chalk.bold('  Authenticated User'))
-        if (user.name) this.log(`  Name:       ${user.name}`)
-        if (user.email) this.log(`  Email:      ${user.email}`)
-      } catch {
-        // Silently ignore — identity display is best-effort
-      }
+        }),
+      )
+    }
+  }
+
+  async #oauthStatus() {
+    const tokens = await getOAuthTokens(this.activeProfile)
+
+    if (!tokens) {
+      this.log(`  Auth mode:  OAuth`)
+      this.log(`  Status:     ${chalk.red('Not authenticated')}`)
+      this.log('')
+      this.log(`Run ${chalk.cyan('pdcli auth login --oauth')} to authenticate.`)
+      return
+    }
+
+    const remainingMin = Math.max(
+      0,
+      Math.round((tokens.expiresAt - Date.now()) / 60_000),
+    )
+    this.log(`  API host:   ${tokens.apiDomain}`)
+    this.log(`  Auth mode:  OAuth (auto-refresh)`)
+    this.log(
+      `  Token:      ${chalk.green('present')} (expires in ${remainingMin}m)`,
+    )
+
+    await this.#showIdentity(
+      createClient({
+        apiDomain: tokens.apiDomain,
+        token: tokens.accessToken,
+        authMode: 'oauth',
+        retry: false,
+        userAgent: `pdcli/${this.config.version}`,
+      }),
+    )
+  }
+
+  async #showIdentity(client) {
+    try {
+      const user = await validateToken(client)
+      this.log('')
+      this.log(chalk.bold('  Authenticated User'))
+      if (user.name) this.log(`  Name:       ${user.name}`)
+      if (user.email) this.log(`  Email:      ${user.email}`)
+    } catch {
+      // Silently ignore — identity display is best-effort
     }
   }
 }