@indemn/cli 1.5.0 → 1.7.0

package/src/sdk/auth.ts

@@ -1,11 +1,13 @@
 import { initializeApp, getApp } from 'firebase/app';
 import { getAuth, signInWithEmailAndPassword } from 'firebase/auth';
-import { IndemnClient } from './client.js';
-import type { Environment, EnvironmentHosts } from './types.js';
+import { DEFAULT_HOSTS, IndemnClient } from './client.js';
+import { exchangeIdToken, toStoredSession } from './session.js';
+import type { Credential } from './credentials.js';
+import type { Environment, EnvironmentHosts, OrgSummary } from './types.js';
 
 // Firebase client configs per environment — public configuration (not secrets),
 // bundled the same way the Copilot Dashboard bundles them via envsubst
-const FIREBASE_CONFIGS: Record<Environment, Record<string, string>> = {
+export const FIREBASE_CONFIGS: Record<Environment, Record<string, string>> = {
   dev: {
     apiKey: 'AIzaSyB8bA3w8oaMbyMxYA7lyQy_OvrPcPfW7x8',
     authDomain: 'agent-449107.firebaseapp.com',
@@ -24,127 +26,105 @@ const FIREBASE_CONFIGS: Record<Environment, Record<string, string>> = {
   },
 };
 
-export async function login(email: string, password: string, env: Environment = 'dev', opts?: {
-  mfaCodePrompt?: () => Promise<string>;
-}): Promise<{
-  apiKey: string;
-  orgId: string;
-  userId: string;
-  environment: Environment;
-}> {
-  // Step 1: Firebase client SDK auth (environment-specific config, separate app per env)
-  const firebaseConfig = FIREBASE_CONFIGS[env];
+export type FirebaseSignIn = (email: string, password: string, env: Environment) => Promise<{ idToken: string; refreshToken: string }>;
+
+/** Email and password sign-in with the Firebase web SDK, as the dashboard does. */
+const firebaseSignIn: FirebaseSignIn = async (email, password, env) => {
   const appName = `indemn-cli-${env}`;
   let app;
-  try { app = getApp(appName); } catch { app = initializeApp(firebaseConfig, appName); }
-  const auth = getAuth(app);
-  const userCredential = await signInWithEmailAndPassword(auth, email, password);
-  const idToken = await userCredential.user.getIdToken();
-
-  // Step 2: Exchange Firebase ID token for Copilot Server JWT
-  const client = new IndemnClient({ environment: env });
-  const signinResponse = await client.copilotPostUnauth<{
-    success: boolean;
-    requiresMfa: boolean;
-    mfaSessionId?: string;
-    mfaEmail?: string;
-    token?: string;
-    user?: { _id: string; email: string };
-  }>('/auth/firebase/signin', { idToken });
-
-  let jwt: string;
-  let userId: string;
+  try { app = getApp(appName); } catch { app = initializeApp(FIREBASE_CONFIGS[env], appName); }
+  const credential = await signInWithEmailAndPassword(getAuth(app), email, password);
+  return { idToken: await credential.user.getIdToken(), refreshToken: credential.user.refreshToken };
+};
 
-  if (signinResponse.requiresMfa) {
-    // MFA required — prompt for code and verify
-    if (!opts?.mfaCodePrompt) {
-      throw new Error('MFA is required but no code prompt handler was provided.');
-    }
-    const code = await opts.mfaCodePrompt();
-    const mfaResponse = await client.copilotPostUnauth<{
-      success: boolean;
-      token: string;
-      user: { _id: string; email: string };
-    }>('/auth/firebase/mfa/verify', {
-      sessionId: signinResponse.mfaSessionId,
-      code,
-    });
-    jwt = mfaResponse.token.replace(/^JWT\s+/i, '');
-    userId = mfaResponse.user._id;
-  } else {
-    // No MFA — direct JWT
-    jwt = signinResponse.token!.replace(/^JWT\s+/i, '');
-    userId = signinResponse.user!._id;
-  }
+export interface LoginResult {
+  userId: string;
+  email: string;
+  environment: Environment;
+  orgs: OrgSummary[];
+  expiresAt?: string;
+}
 
-  // Step 3: Generate persistent API key using the JWT
-  const apiKeyResponse = await client.copilotPostUnauth<{
-    _id: string;
-    key: string;
-    name: string;
-    org_id: string;
-  }>('/auth/api-keys', { name: `indemn-cli-${Date.now()}` }, {
-    'Authorization': `jwt ${jwt}`,
-  });
+/**
+ * Log in and keep the copilot session token, the same one the dashboard uses.
+ * No API key is created. The Firebase refresh token is kept so the session
+ * can renew itself.
+ */
+export async function login(email: string, password: string, env: Environment = 'dev', opts?: {
+  mfaCodePrompt?: () => Promise<string>;
+  firebaseSignIn?: FirebaseSignIn;
+}): Promise<LoginResult> {
+  const { idToken, refreshToken } = await (opts?.firebaseSignIn ?? firebaseSignIn)(email, password, env);
 
-  if (!apiKeyResponse.org_id) {
-    throw new Error('Login succeeded but no organization found. Contact your admin to be added to an organization.');
-  }
+  const unauth = new IndemnClient({ environment: env });
+  const session = await exchangeIdToken(
+    (path, body, headers) => unauth.copilotPostUnauth(path, body, headers),
+    idToken,
+    opts?.mfaCodePrompt,
+  );
 
-  // Step 3.5: Fetch the org name so the banner can display it without a lookup on every command.
-  let orgName: string | undefined;
-  try {
-    const orgRes = await fetch(`${client.getHosts().copilot}/organization/${apiKeyResponse.org_id}`, {
-      headers: {
-        'Authorization': `Bearer ${apiKeyResponse.key}`,
-        'Content-Type': 'application/json',
-      },
-    });
-    if (orgRes.ok) {
-      const data = await orgRes.json() as { organization?: { name?: string } };
-      orgName = data.organization?.name;
-    }
-  } catch {
-    // Non-fatal — banner falls back to org ID if name unavailable
-  }
+  // Which orgs this person belongs to, asked with the new session itself.
+  const authed = new IndemnClient({ environment: env, token: session.token });
+  const res = await authed.copilotGet<{ userOrganizations?: Array<{ _id: string; name: string }> }>('/organization');
+  const orgs = (res.userOrganizations ?? []).map((o) => ({ id: String(o._id), name: o.name }));
 
-  const config = {
-    api_key: apiKeyResponse.key,
-    org_id: apiKeyResponse.org_id,
-    org_name: orgName,
-    user_id: userId,
+  const stored = toStoredSession(session.token, refreshToken);
+  IndemnClient.clearConfig();
+  IndemnClient.saveConfig({
     environment: env,
-  };
-
-  // Step 4: Save to config file
-  IndemnClient.saveConfig(config);
+    user_id: session.userId,
+    email: session.email ?? email,
+    session: stored,
+    orgs,
+    hosts: DEFAULT_HOSTS,
+  });
 
-  return {
-    apiKey: config.api_key,
-    orgId: config.org_id,
-    userId: config.user_id,
-    environment: env,
-  };
+  return { userId: session.userId, email: session.email ?? email, environment: env, orgs, expiresAt: stored.expires_at };
 }
 
-export function logout(): void {
+/** Revoke the session on the server, then forget it locally. */
+export async function logout(): Promise<{ revoked: boolean }> {
+  const config = IndemnClient.loadConfig();
+  let revoked = false;
+  if (config?.session?.token) {
+    try {
+      const client = new IndemnClient({ environment: config.environment });
+      await client.copilotPostUnauth('/auth/firebase/logout', undefined, { Authorization: `JWT ${config.session.token}` });
+      revoked = true;
+    } catch {
+      // Offline or already expired: still forget it locally.
+    }
+  }
   IndemnClient.clearConfig();
+  return { revoked };
 }
 
-export function whoami(): {
-  apiKey: string;
-  orgId: string;
-  userId: string;
+export interface WhoAmI {
   environment: Environment;
+  email?: string;
+  userId?: string;
+  credential: 'session' | 'api_key';
+  source: Credential['source'];
+  sessionExpiresAt?: string;
+  orgs: OrgSummary[];
   hosts: EnvironmentHosts;
-} | null {
+}
+
+/** Who and where, without any secret. */
+export function whoami(): WhoAmI | null {
+  const client = new IndemnClient();
+  const cred = client.getCredential();
+  if (!cred) return null;
   const config = IndemnClient.loadConfig();
-  if (!config || !config.api_key) return null;
+  const fromConfig = cred.source === 'config';
   return {
-    apiKey: config.api_key.substring(0, 12) + '...',
-    orgId: config.org_id,
-    userId: config.user_id,
-    environment: config.environment,
-    hosts: config.hosts[config.environment],
+    environment: client.getEnvironment(),
+    email: fromConfig ? config?.email : undefined,
+    userId: fromConfig ? config?.user_id : undefined,
+    credential: cred.kind === 'token' ? 'session' : 'api_key',
+    source: cred.source,
+    sessionExpiresAt: fromConfig && cred.kind === 'token' ? config?.session?.expires_at : undefined,
+    orgs: fromConfig ? config?.orgs ?? [] : [],
+    hosts: client.getHosts(),
   };
 }

package/src/sdk/billing.ts

@@ -0,0 +1,59 @@
+import type { IndemnClient } from './client.js';
+
+/**
+ * Billing, READ-ONLY by design: every call here is a GET. The CLI never
+ * changes a plan, pays, pauses, cancels, posts meters or edits prices; those
+ * stay in the dashboard. (A test fails if this file gains a write.)
+ */
+export class BillingSDK {
+  constructor(private client: IndemnClient) {}
+
+  /** The org's subscription, or null when it has none (copilot answers 500 then) or never pays (infinite plan). */
+  async status(): Promise<Record<string, unknown> | null> {
+    try {
+      const res = await this.client.copilotGet<Record<string, unknown>>('/organization/:org_id/billing-subscription');
+      return res;
+    } catch (err) {
+      if (err instanceof Error && /\(500\)|infinite subscription|Subscription does not exist/i.test(err.message)) return null;
+      throw err;
+    }
+  }
+
+  private async subscriptionId(): Promise<string | null> {
+    const sub = await this.status();
+    return sub && sub._id ? String(sub._id) : null;
+  }
+
+  /** Invoices, newest first (empty when there are none; copilot answers 500 then). */
+  async invoices(): Promise<unknown[]> {
+    const sid = await this.subscriptionId();
+    if (!sid) return [];
+    try {
+      const res = await this.client.copilotGet<{ invoices?: unknown[] }>(`/invoice/organization/:org_id/subscription/${sid}`);
+      return res.invoices ?? [];
+    } catch (err) {
+      if (err instanceof Error && /\(500\)|Could not fetch invoices/i.test(err.message)) return [];
+      throw err;
+    }
+  }
+
+  /** Open invoices with their payment links. */
+  async unpaid(): Promise<unknown[]> {
+    const sid = await this.subscriptionId();
+    if (!sid) return [];
+    const res = await this.client.copilotGet<{ unpaidInvoices?: unknown[] }>(`/invoice/organization/:org_id/subscription/${sid}/unpaid`);
+    return res.unpaidInvoices ?? [];
+  }
+
+  /** Usage so far this period and the projected cost per meter. */
+  usageForecast(): Promise<unknown> {
+    return this.client.copilotGet('/invoice/organization/:org_id/usage-forecast');
+  }
+
+  /** The org's own plans and the public plan list. */
+  async plans(): Promise<{ org_plans: unknown[]; public_plans: unknown[] }> {
+    const org = await this.client.copilotGet<{ plans?: unknown[] }>('/organization/:org_id/customer-plans').catch(() => ({ plans: [] }));
+    const pub = await this.client.copilotGet<unknown[]>('/subscription-plans').catch(() => []);
+    return { org_plans: org.plans ?? [], public_plans: Array.isArray(pub) ? pub : [] };
+  }
+}

package/src/sdk/campaigns.ts

@@ -0,0 +1,60 @@
+import type { IndemnClient } from './client.js';
+import { CliError, EXIT } from '../core/runtime.js';
+
+/** Paths of the campaigns service the CLI may read. Everything else, and every write, is refused. */
+const READABLE = [
+  /^\/campaigns$/,
+  /^\/campaigns\/[\w-]+$/,
+  /^\/campaigns\/[\w-]+\/(versions|counts|forecast|next-touchpoints)$/,
+  /^\/templates$/,
+  /^\/templates\/[\w-]+$/,
+  /^\/templates\/[\w-]+\/versions$/,
+  /^\/template-skills$/,
+  /^\/template-skills\/[\w-]+$/,
+];
+
+/**
+ * Campaigns, READ-ONLY by design, through copilot's proxy to the campaigns
+ * service. The CLI never publishes a campaign, sends a communication or
+ * triggers a book sync; those act on real customers.
+ */
+export class CampaignsSDK {
+  constructor(private client: IndemnClient) {}
+
+  private async read<T>(path: string, query?: Record<string, string>): Promise<T> {
+    if (!READABLE.some((r) => r.test(path))) throw new CliError(`Campaigns path ${path} is not readable from the CLI.`, EXIT.NEEDS_INPUT);
+    return this.client.copilotGet<T>(`/organization/:org_id/campaigns-service${path}`, query);
+  }
+
+  list(filter: { status?: string; solutionId?: string; limit?: number; skip?: number } = {}): Promise<{ total?: number; items?: unknown[] }> {
+    const q: Record<string, string> = { limit: String(Math.min(filter.limit ?? 50, 500)), skip: String(filter.skip ?? 0) };
+    if (filter.status) q.status = filter.status;
+    if (filter.solutionId) q.solution_id = filter.solutionId;
+    return this.read('/campaigns', q);
+  }
+
+  get(id: string): Promise<unknown> {
+    return this.read(`/campaigns/${id}`);
+  }
+
+  /** Enrollment counts, forecast of the next days, or upcoming touchpoints of a campaign. */
+  detail(id: string, what: 'counts' | 'forecast' | 'next-touchpoints' | 'versions', days?: number): Promise<unknown> {
+    return this.read(`/campaigns/${id}/${what}`, days ? { days: String(days) } : undefined);
+  }
+
+  templates(filter: { channel?: string; solutionId?: string; limit?: number } = {}): Promise<{ total?: number; items?: unknown[] }> {
+    const q: Record<string, string> = { limit: String(Math.min(filter.limit ?? 50, 500)) };
+    if (filter.channel) q.channel = filter.channel;
+    if (filter.solutionId) q.solution_id = filter.solutionId;
+    return this.read('/templates', q);
+  }
+
+  /** A template; with versions: true, its versions (where subject and body live). */
+  template(id: string, versions = false): Promise<unknown> {
+    return this.read(versions ? `/templates/${id}/versions` : `/templates/${id}`);
+  }
+
+  templateSkills(solutionId?: string): Promise<unknown> {
+    return this.read('/template-skills', solutionId ? { solution_id: solutionId } : undefined);
+  }
+}

package/src/sdk/chat.ts

@@ -11,19 +11,42 @@ export class ChatSession extends EventEmitter {
   private connected = false;
   private streamBuffers: Map<string, string> = new Map();
 
-  constructor(botType: string, middlewareUrl: string, sessionId?: string) {
+  private customData: Record<string, unknown>;
+
+  /**
+   * Every CLI conversation is a test conversation: `isTestMode` is always
+   * true and cannot be overridden. `tester` and `preview` let the dashboard
+   * show who tested, as it does for its own "Talk to agent" window.
+   */
+  constructor(
+    botType: string,
+    middlewareUrl: string,
+    sessionId?: string,
+    opts: { tester?: string | null; preview?: string | null; customData?: Record<string, unknown> } = {},
+  ) {
     super();
     this.botType = botType;
     this.middlewareUrl = middlewareUrl;
     this.userId = `cli-user-${Date.now()}`;
     this.sessionId = sessionId || null;
+    this.customData = {
+      ...opts.customData,
+      ...(opts.tester ? { conversation_tester: opts.tester } : {}),
+      ...(opts.preview ? { preview: opts.preview } : {}),
+      isTestMode: true,
+    };
+  }
+
+  /** The custom data sent with session_request (for tests and diagnostics). */
+  getCustomData(): Record<string, unknown> {
+    return { ...this.customData };
   }
 
   async connect(): Promise<string> {
     return new Promise<string>((resolve, reject) => {
       const timeout = setTimeout(() => {
         reject(new Error('Connection timed out after 10s'));
-        this.disconnect();
+        void this.disconnect({ end: false });
       }, 10000);
 
       this.socket = io(this.middlewareUrl, {
@@ -42,7 +65,7 @@ export class ChatSession extends EventEmitter {
           session_id: this.sessionId,
           bot_type: this.botType,
           user_id: this.userId,
-          customData: {},
+          customData: this.customData,
         };
         this.socket!.emit('session_request', request);
       });
@@ -115,15 +138,26 @@ export class ChatSession extends EventEmitter {
     this.socket.emit('user_uttered', payload);
   }
 
-  disconnect(): void {
-    if (this.socket) {
-      if (this.sessionId) {
-        this.socket.emit('session_closed', { session_id: this.sessionId });
+  /**
+   * Leave the conversation. By default it is also ended on the platform
+   * (session_closed). `{ end: false }` only drops the socket, so the same
+   * session id can continue the conversation later.
+   *
+   * The close message is given time to arrive before the socket drops: an
+   * event that reaches Socket.IO right before the disconnect is discarded.
+   */
+  async disconnect(opts: { end?: boolean; flushMs?: number } = {}): Promise<void> {
+    const socket = this.socket;
+    this.socket = null;
+    this.connected = false;
+    if (socket) {
+      if (this.sessionId && opts.end !== false && socket.connected) {
+        // The middleware accepts only allow-listed reasons; this one records a deliberate close.
+        socket.emit('session_closed', { session_id: this.sessionId, reason: 'client_close_conversation' });
+        await new Promise((resolve) => setTimeout(resolve, opts.flushMs ?? 300));
       }
-      this.socket.disconnect();
-      this.socket = null;
+      socket.disconnect();
     }
-    this.connected = false;
     this.sessionId = null;
   }