@crmy/cli 0.5.1

package/src/commands/assignments.ts

@@ -0,0 +1,164 @@
+// Copyright 2026 CRMy Contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { Command } from 'commander';
+import { getClient } from '../client.js';
+
+export function assignmentsCommand(): Command {
+  const cmd = new Command('assignments').description('Manage assignments (coordination & handoffs)');
+
+  cmd.command('list')
+    .option('--mine', 'Show assignments assigned to me')
+    .option('--delegated', 'Show assignments I created')
+    .option('--status <status>', 'Filter by status')
+    .option('--priority <priority>', 'Filter by priority')
+    .action(async (opts) => {
+      const client = await getClient();
+      const input: Record<string, unknown> = { limit: 20 };
+
+      if (opts.mine) {
+        const whoami = JSON.parse(await client.call('actor_whoami', {}));
+        input.assigned_to = whoami.actor_id;
+      }
+      if (opts.delegated) {
+        const whoami = JSON.parse(await client.call('actor_whoami', {}));
+        input.assigned_by = whoami.actor_id;
+      }
+      if (opts.status) input.status = opts.status;
+      if (opts.priority) input.priority = opts.priority;
+
+      const result = await client.call('assignment_list', input);
+      const data = JSON.parse(result);
+      if (data.assignments?.length === 0) {
+        console.log('No assignments found.');
+        return;
+      }
+      console.table(data.assignments?.map((a: Record<string, unknown>) => ({
+        id: (a.id as string).slice(0, 8),
+        title: (a.title as string).slice(0, 40),
+        type: a.assignment_type,
+        status: a.status,
+        priority: a.priority,
+        subject: `${a.subject_type}:${(a.subject_id as string).slice(0, 8)}`,
+      })));
+      if (data.total > 20) console.log(`\n  Showing 20 of ${data.total} assignments`);
+      await client.close();
+    });
+
+  cmd.command('create')
+    .description('Create a new assignment')
+    .action(async () => {
+      const { default: inquirer } = await import('inquirer');
+      const answers = await inquirer.prompt([
+        { type: 'input', name: 'title', message: 'Title:' },
+        { type: 'input', name: 'description', message: 'Description:' },
+        { type: 'list', name: 'assignment_type', message: 'Type:', choices: ['follow_up', 'review', 'approve', 'send', 'call', 'meet', 'research', 'draft', 'custom'] },
+        { type: 'input', name: 'assigned_to', message: 'Assign to (actor UUID):' },
+        { type: 'list', name: 'subject_type', message: 'Subject type:', choices: ['contact', 'account', 'opportunity', 'use_case'] },
+        { type: 'input', name: 'subject_id', message: 'Subject ID (UUID):' },
+        { type: 'list', name: 'priority', message: 'Priority:', choices: ['low', 'normal', 'high', 'urgent'], default: 'normal' },
+        { type: 'input', name: 'context', message: 'Context / handoff notes:' },
+      ]);
+
+      const client = await getClient();
+      const result = await client.call('assignment_create', {
+        title: answers.title,
+        description: answers.description || undefined,
+        assignment_type: answers.assignment_type,
+        assigned_to: answers.assigned_to,
+        subject_type: answers.subject_type,
+        subject_id: answers.subject_id,
+        priority: answers.priority,
+        context: answers.context || undefined,
+      });
+      const data = JSON.parse(result);
+      console.log(`\n  Created assignment: ${data.assignment.id}\n`);
+      await client.close();
+    });
+
+  cmd.command('get <id>')
+    .action(async (id) => {
+      const client = await getClient();
+      const result = await client.call('assignment_get', { id });
+      console.log(JSON.parse(result));
+      await client.close();
+    });
+
+  cmd.command('accept <id>')
+    .description('Accept a pending assignment')
+    .action(async (id) => {
+      const client = await getClient();
+      const result = await client.call('assignment_accept', { id });
+      const data = JSON.parse(result);
+      console.log(`\n  Accepted assignment: ${data.assignment.id} (status: ${data.assignment.status})\n`);
+      await client.close();
+    });
+
+  cmd.command('complete <id>')
+    .option('--activity <activityId>', 'Link the completing activity')
+    .description('Complete an assignment')
+    .action(async (id, opts) => {
+      const client = await getClient();
+      const result = await client.call('assignment_complete', {
+        id,
+        completed_by_activity_id: opts.activity || undefined,
+      });
+      const data = JSON.parse(result);
+      console.log(`\n  Completed assignment: ${data.assignment.id}\n`);
+      await client.close();
+    });
+
+  cmd.command('decline <id>')
+    .option('-r, --reason <reason>', 'Reason for declining')
+    .description('Decline an assignment')
+    .action(async (id, opts) => {
+      const client = await getClient();
+      const result = await client.call('assignment_decline', {
+        id,
+        reason: opts.reason || undefined,
+      });
+      const data = JSON.parse(result);
+      console.log(`\n  Declined assignment: ${data.assignment.id}\n`);
+      await client.close();
+    });
+
+  cmd.command('start <id>')
+    .description('Start working on an accepted assignment')
+    .action(async (id) => {
+      const client = await getClient();
+      const result = await client.call('assignment_start', { id });
+      const data = JSON.parse(result);
+      console.log(`\n  Started assignment: ${data.assignment.id} (status: ${data.assignment.status})\n`);
+      await client.close();
+    });
+
+  cmd.command('block <id>')
+    .option('-r, --reason <reason>', 'Reason for blocking')
+    .description('Mark an assignment as blocked')
+    .action(async (id, opts) => {
+      const client = await getClient();
+      const result = await client.call('assignment_block', {
+        id,
+        reason: opts.reason || undefined,
+      });
+      const data = JSON.parse(result);
+      console.log(`\n  Blocked assignment: ${data.assignment.id}\n`);
+      await client.close();
+    });
+
+  cmd.command('cancel <id>')
+    .option('-r, --reason <reason>', 'Reason for cancelling')
+    .description('Cancel an assignment')
+    .action(async (id, opts) => {
+      const client = await getClient();
+      const result = await client.call('assignment_cancel', {
+        id,
+        reason: opts.reason || undefined,
+      });
+      const data = JSON.parse(result);
+      console.log(`\n  Cancelled assignment: ${data.assignment.id}\n`);
+      await client.close();
+    });
+
+  return cmd;
+}

package/src/commands/auth.ts

@@ -0,0 +1,161 @@
+// Copyright 2026 CRMy Contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { Command } from 'commander';
+import { loadAuthState, saveAuthState, clearAuthState, resolveServerUrl } from '../config.js';
+
+export function authCommand(): Command {
+  const cmd = new Command('auth').description('Authenticate against a CRMy server');
+
+  // crmy auth setup
+  cmd.command('setup')
+    .description('Configure the CRMy server URL')
+    .argument('[url]', 'Server URL (e.g. http://localhost:3000)')
+    .action(async (urlArg?: string) => {
+      let serverUrl = urlArg;
+
+      if (!serverUrl) {
+        const { default: inquirer } = await import('inquirer');
+        const answers = await inquirer.prompt([
+          {
+            type: 'input',
+            name: 'serverUrl',
+            message: 'CRMy server URL:',
+            default: 'http://localhost:3000',
+          },
+        ]);
+        serverUrl = answers.serverUrl;
+      }
+
+      // Validate the URL by hitting the health endpoint
+      try {
+        const res = await fetch(`${serverUrl!.replace(/\/$/, '')}/health`);
+        if (!res.ok) {
+          console.error(`Server at ${serverUrl} returned ${res.status}`);
+          process.exit(1);
+        }
+        const data = await res.json() as { status: string; version: string };
+        console.log(`\n  Connected to CRMy ${data.version} at ${serverUrl}\n`);
+        console.log('  Run `crmy login` to authenticate.\n');
+
+        // Save a partial auth state with just the server URL
+        const existing = loadAuthState();
+        if (existing) {
+          saveAuthState({ ...existing, serverUrl: serverUrl! });
+        } else {
+          // Store server URL for login to pick up
+          saveAuthState({
+            serverUrl: serverUrl!,
+            token: '',
+            user: { id: '', email: '', name: '', role: '', tenant_id: '' },
+          });
+        }
+      } catch (err) {
+        console.error(`Could not connect to ${serverUrl}: ${err instanceof Error ? err.message : err}`);
+        process.exit(1);
+      }
+    });
+
+  // crmy login
+  cmd.command('login')
+    .description('Sign in with email and password')
+    .option('-e, --email <email>', 'Email address')
+    .option('-p, --password <password>', 'Password')
+    .action(async (opts) => {
+      const serverUrl = resolveServerUrl();
+      if (!serverUrl) {
+        console.error('No server configured. Run `crmy auth setup` first.');
+        process.exit(1);
+      }
+
+      let email = opts.email;
+      let password = opts.password;
+
+      if (!email || !password) {
+        const { default: inquirer } = await import('inquirer');
+        const answers = await inquirer.prompt([
+          ...(email ? [] : [{ type: 'input', name: 'email', message: 'Email:' }]),
+          ...(password ? [] : [{ type: 'password', name: 'password', message: 'Password:', mask: '*' }]),
+        ]);
+        email = email ?? answers.email;
+        password = password ?? answers.password;
+      }
+
+      try {
+        const res = await fetch(`${serverUrl.replace(/\/$/, '')}/auth/login`, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ email, password }),
+        });
+
+        if (!res.ok) {
+          const body = await res.json().catch(() => ({ detail: res.statusText })) as { detail?: string };
+          console.error(`Login failed: ${body.detail ?? res.statusText}`);
+          process.exit(1);
+        }
+
+        const data = await res.json() as {
+          token: string;
+          user: { id: string; email: string; name: string; role: string; tenant_id: string };
+        };
+
+        // Decode JWT to get expiration
+        const payloadB64 = data.token.split('.')[1];
+        const payload = JSON.parse(Buffer.from(payloadB64, 'base64url').toString());
+        const expiresAt = payload.exp ? new Date(payload.exp * 1000).toISOString() : undefined;
+
+        saveAuthState({
+          serverUrl,
+          token: data.token,
+          user: data.user,
+          expiresAt,
+        });
+
+        console.log(`\n  Logged in as ${data.user.name} (${data.user.email})`);
+        console.log(`  Role: ${data.user.role}`);
+        if (expiresAt) {
+          console.log(`  Token expires: ${new Date(expiresAt).toLocaleString()}`);
+        }
+        console.log();
+      } catch (err) {
+        console.error(`Login failed: ${err instanceof Error ? err.message : err}`);
+        process.exit(1);
+      }
+    });
+
+  // crmy auth status
+  cmd.command('status')
+    .description('Show current authentication status')
+    .action(() => {
+      const auth = loadAuthState();
+      if (!auth || !auth.token) {
+        console.log('\n  Not authenticated. Run `crmy login` to sign in.\n');
+        return;
+      }
+
+      console.log(`\n  Server:  ${auth.serverUrl}`);
+      console.log(`  User:    ${auth.user.name} (${auth.user.email})`);
+      console.log(`  Role:    ${auth.user.role}`);
+      if (auth.expiresAt) {
+        const expires = new Date(auth.expiresAt);
+        const remaining = expires.getTime() - Date.now();
+        if (remaining <= 0) {
+          console.log('  Token:   Expired — run `crmy login` to re-authenticate');
+        } else {
+          const mins = Math.floor(remaining / 60000);
+          console.log(`  Token:   Valid (${mins}m remaining)`);
+        }
+      }
+      console.log();
+    });
+
+  // crmy auth logout
+  cmd.command('logout')
+    .description('Clear stored credentials')
+    .action(() => {
+      clearAuthState();
+      console.log('\n  Logged out. Credentials cleared.\n');
+    });
+
+  return cmd;
+}

package/src/commands/briefing.ts

@@ -0,0 +1,41 @@
+// SPDX-License-Identifier: Apache-2.0
+
+import { Command } from 'commander';
+import { getClient } from '../client.js';
+
+export function briefingCommand(): Command {
+  const cmd = new Command('briefing')
+    .description('Get a unified briefing for any CRM object — everything you need before taking action')
+    .argument('<subject>', 'Subject as type:UUID (e.g. contact:550e8400-...)')
+    .option('--format <fmt>', 'Output format (json or text)', 'text')
+    .option('--since <duration>', 'Filter activities by duration (e.g. 7d, 24h)')
+    .option('--context-types <types>', 'Comma-separated context types to include')
+    .option('--include-stale', 'Include superseded context entries')
+    .action(async (subject, opts) => {
+      const [subjectType, subjectId] = subject.split(':');
+      if (!subjectType || !subjectId) {
+        console.error('Subject must be in format type:UUID (e.g. contact:550e8400-...)');
+        process.exit(1);
+      }
+
+      const client = await getClient();
+      const result = await client.call('briefing_get', {
+        subject_type: subjectType,
+        subject_id: subjectId,
+        format: opts.format,
+        since: opts.since,
+        context_types: opts.contextTypes ? opts.contextTypes.split(',') : undefined,
+        include_stale: opts.includeStale ?? false,
+      });
+
+      const data = JSON.parse(result);
+      if (opts.format === 'text' && data.briefing_text) {
+        console.log(data.briefing_text);
+      } else {
+        console.log(JSON.stringify(data, null, 2));
+      }
+      await client.close();
+    });
+
+  return cmd;
+}

package/src/commands/config.ts

@@ -0,0 +1,25 @@
+// Copyright 2026 CRMy Contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { Command } from 'commander';
+import { loadConfigFile } from '../config.js';
+
+export function configCommand(): Command {
+  return new Command('config')
+    .description('Show configuration')
+    .command('show')
+    .action(() => {
+      const config = loadConfigFile();
+      if (Object.keys(config).length === 0) {
+        console.log('No .crmy.json found. Run `crmy init` to create one.');
+        return;
+      }
+      // Redact sensitive values
+      const display = {
+        ...config,
+        apiKey: config.apiKey ? config.apiKey.slice(0, 10) + '...' : undefined,
+        jwtSecret: config.jwtSecret ? '***' : undefined,
+      };
+      console.log(JSON.stringify(display, null, 2));
+    });
+}

package/src/commands/contacts.ts

@@ -0,0 +1,83 @@
+// Copyright 2026 CRMy Contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { Command } from 'commander';
+import { getClient } from '../client.js';
+
+export function contactsCommand(): Command {
+  const cmd = new Command('contacts').description('Manage contacts');
+
+  cmd.command('list')
+    .option('-q, --query <query>', 'Search query')
+    .option('--stage <stage>', 'Filter by lifecycle stage')
+    .action(async (opts) => {
+      const client = await getClient();
+      const result = await client.call('contact_search', {
+        query: opts.query,
+        lifecycle_stage: opts.stage,
+        limit: 20,
+      });
+      const data = JSON.parse(result);
+      if (data.contacts?.length === 0) {
+        console.log('No contacts found.');
+        return;
+      }
+      console.table(data.contacts?.map((c: Record<string, unknown>) => ({
+        id: (c.id as string).slice(0, 8),
+        name: `${c.first_name} ${c.last_name}`,
+        email: c.email ?? '',
+        stage: c.lifecycle_stage,
+        company: c.company_name ?? '',
+      })));
+      if (data.total > 20) console.log(`\n  Showing 20 of ${data.total} contacts`);
+      await client.close();
+    });
+
+  cmd.command('get <id>')
+    .action(async (id) => {
+      const client = await getClient();
+      const result = await client.call('contact_get', { id });
+      console.log(JSON.parse(result));
+      await client.close();
+    });
+
+  cmd.command('create')
+    .action(async () => {
+      const { default: inquirer } = await import('inquirer');
+      const answers = await inquirer.prompt([
+        { type: 'input', name: 'first_name', message: 'First name:' },
+        { type: 'input', name: 'last_name', message: 'Last name:' },
+        { type: 'input', name: 'email', message: 'Email:' },
+        { type: 'input', name: 'company_name', message: 'Company:' },
+      ]);
+
+      const client = await getClient();
+      const result = await client.call('contact_create', {
+        first_name: answers.first_name,
+        last_name: answers.last_name || undefined,
+        email: answers.email || undefined,
+        company_name: answers.company_name || undefined,
+      });
+      const data = JSON.parse(result);
+      console.log(`\n  Created contact: ${data.contact.id}\n`);
+      await client.close();
+    });
+
+  cmd.command('delete <id>')
+    .description('Permanently delete a contact (admin/owner only)')
+    .action(async (id) => {
+      const { default: inquirer } = await import('inquirer');
+      const { confirm } = await inquirer.prompt([
+        { type: 'confirm', name: 'confirm', message: `Delete contact ${id}? This cannot be undone.`, default: false },
+      ]);
+      if (!confirm) { console.log('  Cancelled.'); return; }
+
+      const client = await getClient();
+      const result = await client.call('contact_delete', { id });
+      const data = JSON.parse(result);
+      if (data.deleted) console.log(`  Deleted.`);
+      await client.close();
+    });
+
+  return cmd;
+}

package/src/commands/context-types.ts

@@ -0,0 +1,56 @@
+// SPDX-License-Identifier: Apache-2.0
+
+import { Command } from 'commander';
+import { getClient } from '../client.js';
+
+export function contextTypesCommand(): Command {
+  const cmd = new Command('context-types').description('Manage context type registry');
+
+  cmd.command('list')
+    .action(async () => {
+      const client = await getClient();
+      const result = await client.call('context_type_list', {});
+      const data = JSON.parse(result);
+      if (data.context_types?.length === 0) {
+        console.log('No context types found.');
+        return;
+      }
+      console.table(data.context_types?.map((t: Record<string, unknown>) => ({
+        type_name: t.type_name,
+        label: t.label,
+        description: ((t.description as string) ?? '').slice(0, 60),
+        default: t.is_default ? '✓' : '',
+      })));
+      await client.close();
+    });
+
+  cmd.command('add <type_name>')
+    .requiredOption('--label <label>', 'Display label')
+    .option('--description <desc>', 'Description')
+    .action(async (typeName, opts) => {
+      const client = await getClient();
+      const result = await client.call('context_type_add', {
+        type_name: typeName,
+        label: opts.label,
+        description: opts.description,
+      });
+      const data = JSON.parse(result);
+      console.log(`\n  Added context type: ${data.context_type.type_name}\n`);
+      await client.close();
+    });
+
+  cmd.command('remove <type_name>')
+    .description('Remove a custom context type (cannot remove defaults)')
+    .action(async (typeName) => {
+      const client = await getClient();
+      try {
+        await client.call('context_type_remove', { type_name: typeName });
+        console.log(`\n  Removed context type: ${typeName}\n`);
+      } catch (err) {
+        console.error(`\n  Error: ${err instanceof Error ? err.message : err}\n`);
+      }
+      await client.close();
+    });
+
+  return cmd;
+}