@instantkom/cli 3.129.2

package/dist/config/config-file.d.ts

@@ -0,0 +1,36 @@
+/** A profile block is a flat record of non-secret config values. */
+export type ProfileBlock = Record<string, string | number | boolean | undefined>;
+/**
+ * Reads and writes the instantkom CLI config file.
+ *
+ * Top-level YAML keys are profile names per D-37.
+ * Secret keys are refused per D-38.
+ * File is created with mode 0o600 per D-36.
+ */
+export declare class ConfigFile {
+    private readonly filePath;
+    constructor(filePath?: string);
+    /**
+     * Read a named profile block. Returns empty object if file or profile missing.
+     * Per D-37: missing profile = empty object, NOT an error.
+     */
+    read(profile?: string): ProfileBlock;
+    /**
+     * Write a key/value into the named profile block.
+     *
+     * Refuses secret-shaped keys per D-38.
+     * Creates the file with 0o600 mode if absent per D-36.
+     * Warns to stderr if existing file has wider mode.
+     */
+    write(profile: string, key: string, value: string | number | boolean): void;
+    /**
+     * Remove a key from the named profile block.
+     * No-op if file, profile, or key doesn't exist.
+     */
+    unset(profile: string, key: string): void;
+    private readAll;
+    private writeAll;
+    private ensureDir;
+    /** Warn if the existing config file has permissions wider than 0o600. */
+    private checkFileMode;
+}

package/dist/config/config-file.js

@@ -0,0 +1,111 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { parse, stringify } from 'yaml';
+import { configPath } from './config-path.js';
+import { ApiError } from '../errors/api-error.js';
+/** Regex pattern for secret-shaped keys -- refused by write() per D-38. */
+const SECRET_KEY_PATTERN = /token|secret|password|key/i;
+/**
+ * Reads and writes the instantkom CLI config file.
+ *
+ * Top-level YAML keys are profile names per D-37.
+ * Secret keys are refused per D-38.
+ * File is created with mode 0o600 per D-36.
+ */
+export class ConfigFile {
+    filePath;
+    constructor(filePath) {
+        this.filePath = filePath ?? configPath();
+    }
+    /**
+     * Read a named profile block. Returns empty object if file or profile missing.
+     * Per D-37: missing profile = empty object, NOT an error.
+     */
+    read(profile) {
+        const profileName = profile ?? 'default';
+        if (!fs.existsSync(this.filePath)) {
+            return {};
+        }
+        try {
+            const content = fs.readFileSync(this.filePath, 'utf-8');
+            const parsed = parse(content);
+            if (!parsed || typeof parsed !== 'object')
+                return {};
+            return parsed[profileName] ?? {};
+        }
+        catch {
+            return {};
+        }
+    }
+    /**
+     * Write a key/value into the named profile block.
+     *
+     * Refuses secret-shaped keys per D-38.
+     * Creates the file with 0o600 mode if absent per D-36.
+     * Warns to stderr if existing file has wider mode.
+     */
+    write(profile, key, value) {
+        if (SECRET_KEY_PATTERN.test(key)) {
+            throw new ApiError('user_error', `Refusing to write secret key '${key}' to config file. Use 'ikm auth login' to manage credentials.`);
+        }
+        this.ensureDir();
+        this.checkFileMode();
+        const existing = this.readAll();
+        if (!existing[profile]) {
+            existing[profile] = {};
+        }
+        existing[profile][key] = value;
+        this.writeAll(existing);
+    }
+    /**
+     * Remove a key from the named profile block.
+     * No-op if file, profile, or key doesn't exist.
+     */
+    unset(profile, key) {
+        if (!fs.existsSync(this.filePath))
+            return;
+        const existing = this.readAll();
+        if (!existing[profile])
+            return;
+        delete existing[profile][key];
+        this.writeAll(existing);
+    }
+    // ---- private helpers ----
+    readAll() {
+        if (!fs.existsSync(this.filePath))
+            return {};
+        try {
+            const content = fs.readFileSync(this.filePath, 'utf-8');
+            const parsed = parse(content);
+            return (parsed && typeof parsed === 'object') ? parsed : {};
+        }
+        catch {
+            return {};
+        }
+    }
+    writeAll(data) {
+        const content = stringify(data);
+        fs.writeFileSync(this.filePath, content, { mode: 0o600, encoding: 'utf-8' });
+    }
+    ensureDir() {
+        const dir = path.dirname(this.filePath);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+        }
+    }
+    /** Warn if the existing config file has permissions wider than 0o600. */
+    checkFileMode() {
+        if (!fs.existsSync(this.filePath))
+            return;
+        try {
+            const stat = fs.statSync(this.filePath);
+            const mode = stat.mode & 0o777;
+            if (mode > 0o600) {
+                process.stderr.write(`Warning: config file ${this.filePath} has wide permissions (${mode.toString(8)}). Expected 0600.\n`);
+            }
+        }
+        catch {
+            // Ignore stat errors -- file may have been created concurrently
+        }
+    }
+}

package/dist/config/config-path.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Returns the OS-correct config file path per D-36.
+ *
+ * Linux:   $XDG_CONFIG_HOME/instantkom/config.yml || $HOME/.config/instantkom/config.yml
+ * macOS:   ~/Library/Application Support/instantkom/config.yml
+ * Windows: %APPDATA%/instantkom/config.yml
+ */
+export declare function configPath(): string;

package/dist/config/config-path.js

@@ -0,0 +1,25 @@
+import * as os from 'os';
+import * as path from 'path';
+/**
+ * Returns the OS-correct config file path per D-36.
+ *
+ * Linux:   $XDG_CONFIG_HOME/instantkom/config.yml || $HOME/.config/instantkom/config.yml
+ * macOS:   ~/Library/Application Support/instantkom/config.yml
+ * Windows: %APPDATA%/instantkom/config.yml
+ */
+export function configPath() {
+    const platform = process.platform;
+    if (platform === 'win32') {
+        const appData = process.env.APPDATA ?? path.join(os.homedir(), 'AppData', 'Roaming');
+        return path.join(appData, 'instantkom', 'config.yml');
+    }
+    if (platform === 'darwin') {
+        return path.join(os.homedir(), 'Library', 'Application Support', 'instantkom', 'config.yml');
+    }
+    // Linux and other Unix-like systems
+    const xdgConfigHome = process.env.XDG_CONFIG_HOME;
+    const configBase = xdgConfigHome
+        ? xdgConfigHome
+        : path.join(os.homedir(), '.config');
+    return path.join(configBase, 'instantkom', 'config.yml');
+}

package/dist/crud/csv.d.ts

@@ -0,0 +1,6 @@
+export interface CsvRow {
+    rowNumber: number;
+    values: Record<string, string>;
+}
+export declare function parseCsv(input: string): CsvRow[];
+export declare function serializeCsv(rows: Record<string, unknown>[]): string;

package/dist/crud/csv.js

@@ -0,0 +1,89 @@
+import { ApiError } from '../errors/api-error.js';
+function parseCsvRecords(input) {
+    const records = [];
+    let record = [];
+    let cell = '';
+    let inQuotes = false;
+    for (let index = 0; index < input.length; index += 1) {
+        const char = input[index];
+        const next = input[index + 1];
+        if (char === '"') {
+            if (inQuotes && next === '"') {
+                cell += '"';
+                index += 1;
+            }
+            else {
+                inQuotes = !inQuotes;
+            }
+            continue;
+        }
+        if (char === ',' && !inQuotes) {
+            record.push(cell);
+            cell = '';
+            continue;
+        }
+        if ((char === '\n' || char === '\r') && !inQuotes) {
+            if (char === '\r' && next === '\n') {
+                index += 1;
+            }
+            record.push(cell);
+            records.push(record);
+            record = [];
+            cell = '';
+            continue;
+        }
+        cell += char;
+    }
+    if (inQuotes) {
+        throw new ApiError('user_error', 'Invalid CSV: unterminated quoted cell');
+    }
+    record.push(cell);
+    records.push(record);
+    return records.filter((entry) => entry.some((value) => value !== ''));
+}
+export function parseCsv(input) {
+    const records = parseCsvRecords(input);
+    const headers = records[0]?.map((header) => header.trim()) ?? [];
+    if (headers.length === 0) {
+        return [];
+    }
+    if (headers.some((header) => header === '')) {
+        throw new ApiError('user_error', 'Invalid CSV: headers must not be empty');
+    }
+    return records.slice(1).map((record, index) => {
+        const values = {};
+        for (const [headerIndex, header] of headers.entries()) {
+            values[header] = record[headerIndex] ?? '';
+        }
+        return {
+            rowNumber: index + 2,
+            values,
+        };
+    });
+}
+function serializeValue(value) {
+    if (value === undefined || value === null) {
+        return '';
+    }
+    const text = typeof value === 'object' ? JSON.stringify(value) : String(value);
+    if (/[",\r\n]/.test(text)) {
+        return `"${text.replaceAll('"', '""')}"`;
+    }
+    return text;
+}
+export function serializeCsv(rows) {
+    if (rows.length === 0) {
+        return '';
+    }
+    const headers = Array.from(rows.reduce((keys, row) => {
+        for (const key of Object.keys(row)) {
+            keys.add(key);
+        }
+        return keys;
+    }, new Set()));
+    const lines = [
+        headers.map(serializeValue).join(','),
+        ...rows.map((row) => headers.map((header) => serializeValue(row[header])).join(',')),
+    ];
+    return `${lines.join('\n')}\n`;
+}

package/dist/crud/data.d.ts

@@ -0,0 +1,4 @@
+export type JsonObject = Record<string, unknown>;
+export declare function parseDataFlag(value?: string): JsonObject;
+export declare function mergeData(data: JsonObject, flags: Record<string, unknown>): JsonObject;
+export declare function cleanQuery(query: Record<string, unknown>): JsonObject;

package/dist/crud/data.js

@@ -0,0 +1,38 @@
+import { ApiError } from '../errors/api-error.js';
+export function parseDataFlag(value) {
+    if (value === undefined || value.trim() === '') {
+        return {};
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(value);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new ApiError('user_error', `Invalid --data JSON: ${message}`);
+    }
+    if (typeof parsed !== 'object'
+        || parsed === null
+        || Array.isArray(parsed)) {
+        throw new ApiError('user_error', '--data must be a JSON object');
+    }
+    return parsed;
+}
+export function mergeData(data, flags) {
+    const merged = { ...data };
+    for (const [key, value] of Object.entries(flags)) {
+        if (value !== undefined && value !== null && value !== '') {
+            merged[key] = value;
+        }
+    }
+    return merged;
+}
+export function cleanQuery(query) {
+    const cleaned = {};
+    for (const [key, value] of Object.entries(query)) {
+        if (value !== undefined && value !== null && value !== '') {
+            cleaned[key] = value;
+        }
+    }
+    return cleaned;
+}

package/dist/crud/request.d.ts

@@ -0,0 +1,14 @@
+import type { ApiClient, ApiRequestOptions } from '../api-client.js';
+import { type JsonObject } from './data.js';
+type ResourceId = string | number;
+export declare function listResource<T>(client: Pick<ApiClient, 'get'>, path: string, query?: Record<string, unknown>, options?: ApiRequestOptions): Promise<T>;
+export declare function getResource<T>(client: Pick<ApiClient, 'get'>, path: string, id: ResourceId, options?: ApiRequestOptions): Promise<T>;
+export declare function createResource<T>(client: Pick<ApiClient, 'post'>, path: string, payload: JsonObject, options?: ApiRequestOptions): Promise<T>;
+export declare function updateResource<T>(client: Pick<ApiClient, 'put'>, path: string, id: ResourceId, payload: JsonObject, options?: ApiRequestOptions): Promise<T>;
+export declare function deleteResource<T>(client: Pick<ApiClient, 'delete'>, path: string, id: ResourceId, options?: ApiRequestOptions): Promise<T>;
+export declare function downloadResource(client: Pick<ApiClient, 'getBinary'>, path: string, id: ResourceId, query?: Record<string, unknown>): Promise<{
+    buffer: Buffer;
+    contentType: string | null;
+    contentDisposition: string | null;
+}>;
+export {};

package/dist/crud/request.js

@@ -0,0 +1,26 @@
+import { cleanQuery } from './data.js';
+function resourcePath(path, id) {
+    const basePath = path.replace(/\/+$/, '');
+    if (id === undefined) {
+        return basePath;
+    }
+    return `${basePath}/${encodeURIComponent(String(id))}`;
+}
+export async function listResource(client, path, query = {}, options) {
+    return client.get(resourcePath(path), cleanQuery(query), options);
+}
+export async function getResource(client, path, id, options) {
+    return client.get(resourcePath(path, id), undefined, options);
+}
+export async function createResource(client, path, payload, options) {
+    return client.post(resourcePath(path), payload, options);
+}
+export async function updateResource(client, path, id, payload, options) {
+    return client.put(resourcePath(path, id), payload, options);
+}
+export async function deleteResource(client, path, id, options) {
+    return client.delete(resourcePath(path, id), undefined, options);
+}
+export async function downloadResource(client, path, id, query = {}) {
+    return client.getBinary(resourcePath(path, id), cleanQuery(query));
+}

package/dist/errors/api-error.d.ts

@@ -0,0 +1,6 @@
+export type ApiErrorKind = 'unauthorized' | 'rate_limited' | 'server_error' | 'network' | 'user_error';
+export declare class ApiError extends Error {
+    kind: ApiErrorKind;
+    status?: number | undefined;
+    constructor(kind: ApiErrorKind, message: string, status?: number | undefined);
+}

package/dist/errors/api-error.js

@@ -0,0 +1,10 @@
+export class ApiError extends Error {
+    kind;
+    status;
+    constructor(kind, message, status) {
+        super(message);
+        this.kind = kind;
+        this.status = status;
+        this.name = 'ApiError';
+    }
+}

package/dist/errors/exit-codes.d.ts

@@ -0,0 +1,12 @@
+export declare const EXIT_CODES: Readonly<{
+    readonly OK: 0;
+    readonly USER_ERROR: 1;
+    readonly AUTH: 2;
+    readonly RATE_LIMIT: 3;
+    readonly SERVER: 4;
+    readonly NETWORK: 5;
+}>;
+export type ExitCode = (typeof EXIT_CODES)[keyof typeof EXIT_CODES];
+export declare function mapApiErrorToCode(err: {
+    kind?: string;
+}): ExitCode;

package/dist/errors/exit-codes.js

@@ -0,0 +1,24 @@
+export const EXIT_CODES = Object.freeze({
+    OK: 0,
+    USER_ERROR: 1,
+    AUTH: 2,
+    RATE_LIMIT: 3,
+    SERVER: 4,
+    NETWORK: 5,
+});
+export function mapApiErrorToCode(err) {
+    switch (err.kind) {
+        case 'unauthorized':
+            return EXIT_CODES.AUTH;
+        case 'rate_limited':
+            return EXIT_CODES.RATE_LIMIT;
+        case 'server_error':
+            return EXIT_CODES.SERVER;
+        case 'network':
+            return EXIT_CODES.NETWORK;
+        case 'user_error':
+            return EXIT_CODES.USER_ERROR;
+        default:
+            return EXIT_CODES.USER_ERROR;
+    }
+}

package/dist/errors/redact-token.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Redact a token string, showing only first 4 and last 4 characters.
+ * Tokens of 12 chars or fewer are fully redacted to '***' (no leak).
+ */
+export declare function redactToken(token: string): string;
+/**
+ * Redact all token-like strings (>= 24 alphanumeric chars) within a string.
+ * Uses a regex to find and replace each match via redactToken.
+ */
+export declare function redactString(s: string): string;

package/dist/errors/redact-token.js

@@ -0,0 +1,17 @@
+/**
+ * Redact a token string, showing only first 4 and last 4 characters.
+ * Tokens of 12 chars or fewer are fully redacted to '***' (no leak).
+ */
+export function redactToken(token) {
+    if (token.length <= 12) {
+        return '***';
+    }
+    return token.slice(0, 4) + '...' + token.slice(-4);
+}
+/**
+ * Redact all token-like strings (>= 24 alphanumeric chars) within a string.
+ * Uses a regex to find and replace each match via redactToken.
+ */
+export function redactString(s) {
+    return s.replace(/[A-Za-z0-9_-]{24,}/g, (match) => redactToken(match));
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { run } from '@oclif/core';

package/dist/index.js

@@ -0,0 +1 @@
+export { run } from '@oclif/core';

package/dist/output/formatter.d.ts

@@ -0,0 +1,15 @@
+export type FormatMode = 'text' | 'json' | 'yaml' | 'table';
+export interface FormatOptions {
+    columns?: string[];
+    noColor?: boolean;
+}
+/**
+ * Format a payload into a string using the specified mode.
+ *
+ * Modes:
+ *   text  -- human-readable key=value lines (auto-table for homogeneous arrays)
+ *   json  -- JSON.stringify with 2-space indent, trailing newline
+ *   yaml  -- js-yaml dump, sorted keys
+ *   table -- cli-table3 ASCII table
+ */
+export declare function format(payload: unknown, mode: FormatMode, opts?: FormatOptions): string;

package/dist/output/formatter.js

@@ -0,0 +1,57 @@
+import yaml from 'js-yaml';
+import Table from 'cli-table3';
+import { textFormat, isHomogeneousArray } from './text-format.js';
+/**
+ * Format a payload into a string using the specified mode.
+ *
+ * Modes:
+ *   text  -- human-readable key=value lines (auto-table for homogeneous arrays)
+ *   json  -- JSON.stringify with 2-space indent, trailing newline
+ *   yaml  -- js-yaml dump, sorted keys
+ *   table -- cli-table3 ASCII table
+ */
+export function format(payload, mode, opts) {
+    switch (mode) {
+        case 'json':
+            return JSON.stringify(payload, null, 2) + '\n';
+        case 'yaml':
+            return yaml.dump(payload, { sortKeys: true, lineWidth: -1 });
+        case 'table': {
+            const rows = Array.isArray(payload) ? payload : [payload];
+            const firstItem = rows[0];
+            const isObj = typeof firstItem === 'object' && firstItem !== null && !Array.isArray(firstItem);
+            if (!isObj) {
+                // Fallback for non-object payloads
+                return textFormat(payload);
+            }
+            const headers = opts?.columns ?? Object.keys(firstItem);
+            const table = new Table({ head: headers });
+            for (const row of rows) {
+                if (typeof row === 'object' && row !== null) {
+                    const record = row;
+                    table.push(headers.map((h) => {
+                        const v = record[h];
+                        return typeof v === 'object' && v !== null ? JSON.stringify(v) : String(v ?? '');
+                    }));
+                }
+            }
+            return table.toString() + '\n';
+        }
+        case 'text':
+        default: {
+            // Auto-detect homogeneous arrays and render as table
+            if (Array.isArray(payload) && isHomogeneousArray(payload)) {
+                const headers = opts?.columns ?? Object.keys(payload[0]);
+                const table = new Table({ head: headers });
+                for (const row of payload) {
+                    table.push(headers.map((h) => {
+                        const v = row[h];
+                        return typeof v === 'object' && v !== null ? JSON.stringify(v) : String(v ?? '');
+                    }));
+                }
+                return table.toString() + '\n';
+            }
+            return textFormat(payload) + '\n';
+        }
+    }
+}

package/dist/output/text-format.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Detect whether an array is "homogeneous" -- every element has the same
+ * set of own enumerable keys (required for auto-table detection in text mode).
+ */
+declare function isHomogeneousArray(arr: unknown[]): arr is Record<string, unknown>[];
+/**
+ * Format an unknown payload as human-readable text.
+ * - Objects -> key: value lines
+ * - Homogeneous arrays -> tab-aligned table
+ * - Everything else -> JSON.stringify
+ */
+export declare function textFormat(payload: unknown): string;
+export { isHomogeneousArray };

package/dist/output/text-format.js

@@ -0,0 +1,67 @@
+/**
+ * Detect whether an array is "homogeneous" -- every element has the same
+ * set of own enumerable keys (required for auto-table detection in text mode).
+ */
+function isHomogeneousArray(arr) {
+    if (arr.length === 0)
+        return false;
+    const first = arr[0];
+    if (typeof first !== 'object' || first === null)
+        return false;
+    const keys = Object.keys(first).sort().join(',');
+    return arr.every((item) => typeof item === 'object'
+        && item !== null
+        && Object.keys(item).sort().join(',') === keys);
+}
+/**
+ * Format a plain object as key: value lines.
+ */
+function formatRecord(record) {
+    const lines = [];
+    for (const [key, value] of Object.entries(record)) {
+        const display = typeof value === 'object' && value !== null
+            ? JSON.stringify(value)
+            : String(value ?? '');
+        lines.push(`${key}: ${display}`);
+    }
+    return lines.join('\n');
+}
+/**
+ * Format a homogeneous array of objects as a tab-aligned table fallback.
+ * This is the plain-text table (not cli-table3) used in text mode.
+ */
+function formatHomogeneousArray(arr) {
+    if (arr.length === 0)
+        return '';
+    const keys = Object.keys(arr[0]);
+    const rows = arr.map((item) => keys.map((k) => {
+        const v = item[k];
+        return typeof v === 'object' && v !== null ? JSON.stringify(v) : String(v ?? '');
+    }));
+    // Compute column widths
+    const widths = keys.map((k, i) => Math.max(k.length, ...rows.map((r) => r[i].length)));
+    const pad = (s, w) => s.padEnd(w);
+    const header = keys.map((k, i) => pad(k, widths[i])).join('  ');
+    const separator = widths.map((w) => '-'.repeat(w)).join('  ');
+    const body = rows.map((r) => r.map((cell, i) => pad(cell, widths[i])).join('  ')).join('\n');
+    return [header, separator, body].join('\n');
+}
+/**
+ * Format an unknown payload as human-readable text.
+ * - Objects -> key: value lines
+ * - Homogeneous arrays -> tab-aligned table
+ * - Everything else -> JSON.stringify
+ */
+export function textFormat(payload) {
+    if (Array.isArray(payload)) {
+        if (isHomogeneousArray(payload)) {
+            return formatHomogeneousArray(payload);
+        }
+        return payload.map((item) => textFormat(item)).join('\n');
+    }
+    if (typeof payload === 'object' && payload !== null) {
+        return formatRecord(payload);
+    }
+    return String(payload ?? '');
+}
+export { isHomogeneousArray };

package/dist/send/api.d.ts

@@ -0,0 +1,3 @@
+import { ApiClient } from '../api-client.js';
+import type { BaseFlags } from '../base-command.js';
+export declare function createCliApiClient(flags: Partial<BaseFlags>): Promise<ApiClient>;

package/dist/send/api.js

@@ -0,0 +1,21 @@
+import { ApiClient } from '../api-client.js';
+import { resolveToken } from '../auth/token-resolver.js';
+import { ApiError } from '../errors/api-error.js';
+export async function createCliApiClient(flags) {
+    const profile = flags.profile ?? 'default';
+    const token = await resolveToken({
+        flag: flags['api-key'],
+        env: process.env.IKM_API_KEY,
+        profile,
+    });
+    if (!token) {
+        throw new ApiError('unauthorized', 'Not logged in. Run: ikm auth login');
+    }
+    return new ApiClient({
+        id: profile,
+        name: 'ikm-cli',
+        apiUrl: flags['api-url'] ?? process.env.IKM_API_URL ?? 'https://api.instantkom.app',
+        apiKey: token,
+        scope: 'customer',
+    });
+}

package/dist/send/fallback.d.ts

@@ -0,0 +1,5 @@
+import type { ApiClient } from '../api-client.js';
+export declare function resolveFallbackChannels(client: Pick<ApiClient, 'get'>, aliasesCsv: string): Promise<Array<{
+    alias: string;
+    channelId: number;
+}>>;