kimaki 0.23.0 → 0.24.0

package/dist/agent-model.e2e.test.js

@@ -63,6 +63,8 @@ function createDiscordJsClient({ restUrl }) {
         },
     });
 }
+const COMMAND_SYSTEM_CHECK_NAME = 'sys-cmd-check';
+const COMMAND_SYSTEM_CHECK_TEMPLATE = 'Reply with exactly: command-system-check';
 function createDeterministicMatchers() {
     const systemContextMatcher = {
         id: 'system-context-check',
@@ -91,6 +93,37 @@ function createDeterministicMatchers() {
             partDelaysMs: [0, 100, 0, 0, 0],
         },
     };
+    // session.command has no system field. Match an operational kimaki system
+    // instruction (upload helper) so we know the real session system prompt was
+    // injected — not just any string that happens to mention kimaki.dev.
+    // Without the fix this never fires and the bot replies "ok" from the fallback.
+    const commandSystemMatcher = {
+        id: 'command-system-check',
+        priority: 25,
+        when: {
+            lastMessageRole: 'user',
+            latestUserTextIncludes: COMMAND_SYSTEM_CHECK_TEMPLATE,
+            promptTextIncludes: 'kimaki upload-to-discord --session',
+        },
+        then: {
+            parts: [
+                { type: 'stream-start', warnings: [] },
+                { type: 'text-start', id: 'command-system-reply' },
+                {
+                    type: 'text-delta',
+                    id: 'command-system-reply',
+                    delta: 'command-system-ok',
+                },
+                { type: 'text-end', id: 'command-system-reply' },
+                {
+                    type: 'finish',
+                    finishReason: 'stop',
+                    usage: { inputTokens: 1, outputTokens: 1, totalTokens: 2 },
+                },
+            ],
+            partDelaysMs: [0, 100, 0, 0, 0],
+        },
+    };
     const replyContextMatcher = {
         id: 'reply-context-check',
         priority: 15,
@@ -140,7 +173,12 @@ function createDeterministicMatchers() {
             partDelaysMs: [0, 100, 0, 0, 0],
         },
     };
-    return [systemContextMatcher, replyContextMatcher, userReplyMatcher];
+    return [
+        commandSystemMatcher,
+        systemContextMatcher,
+        replyContextMatcher,
+        userReplyMatcher,
+    ];
 }
 /**
  * Create an opencode agent .md file that uses a specific model.
@@ -201,16 +239,25 @@ describe('agent model resolution', () => {
             .pathToFileURL(path.resolve(process.cwd(), '..', 'opencode-deterministic-provider', 'src', 'index.ts'))
             .toString();
         // Build base config with default model
-        const opencodeConfig = buildDeterministicOpencodeConfig({
-            providerName: PROVIDER_NAME,
-            providerNpm,
-            model: DEFAULT_MODEL,
-            smallModel: DEFAULT_MODEL,
-            settings: {
-                strict: false,
-                matchers: createDeterministicMatchers(),
+        const opencodeConfig = {
+            ...buildDeterministicOpencodeConfig({
+                providerName: PROVIDER_NAME,
+                providerNpm,
+                model: DEFAULT_MODEL,
+                smallModel: DEFAULT_MODEL,
+                settings: {
+                    strict: false,
+                    matchers: createDeterministicMatchers(),
+                },
+            }),
+            // OpenCode command used to verify session.command still gets kimaki system
+            command: {
+                [COMMAND_SYSTEM_CHECK_NAME]: {
+                    description: 'Test command for kimaki system prompt injection',
+                    template: COMMAND_SYSTEM_CHECK_TEMPLATE,
+                },
             },
-        });
+        };
         // Add extra models to the provider so opencode accepts them
         const providerConfig = opencodeConfig.provider[PROVIDER_NAME];
         if (!providerConfig) {
@@ -220,6 +267,17 @@ describe('agent model resolution', () => {
         providerConfig.models[PLAN_AGENT_MODEL] = { name: PLAN_AGENT_MODEL };
         providerConfig.models[CHANNEL_MODEL] = { name: CHANNEL_MODEL };
         fs.writeFileSync(path.join(directories.projectDirectory, 'opencode.json'), JSON.stringify(opencodeConfig, null, 2));
+        // Leading /command detection only rewrites when registeredUserCommands is set
+        store.setState({
+            registeredUserCommands: [
+                {
+                    name: COMMAND_SYSTEM_CHECK_NAME,
+                    discordCommandName: `${COMMAND_SYSTEM_CHECK_NAME}-cmd`,
+                    description: 'Test command for kimaki system prompt injection',
+                    source: 'command',
+                },
+            ],
+        });
         // Create agent .md files with custom models
         createAgentFile({
             projectDirectory: directories.projectDirectory,
@@ -387,6 +445,28 @@ describe('agent model resolution', () => {
         *project ⋅ main ⋅ Ns ⋅ N% ⋅ agent-model-v2 ⋅ **test-agent***"
       `);
     }, 15_000);
+    test('session.command path includes kimaki system prompt on first message', async () => {
+        // Leading /command is rewritten to session.command. Without system
+        // injection the matcher requiring "kimaki upload-to-discord --session"
+        // never matches and the bot falls through to the generic "ok" reply.
+        await discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+            content: `/${COMMAND_SYSTEM_CHECK_NAME}`,
+        });
+        const thread = await discord.channel(TEXT_CHANNEL_ID).waitForThread({
+            timeout: 4_000,
+            predicate: (t) => {
+                return t.name === `/${COMMAND_SYSTEM_CHECK_NAME}`;
+            },
+        });
+        await waitForBotMessageContaining({
+            discord,
+            threadId: thread.id,
+            userId: TEST_USER_ID,
+            text: 'command-system-ok',
+            timeout: 4_000,
+        });
+        expect(await discord.thread(thread.id).text()).toContain('command-system-ok');
+    }, 15_000);
     test('reply message injects replied-message context', async () => {
         const db = await getDb();
         await db.delete(schema.channel_agents).where(orm.eq(schema.channel_agents.channel_id, TEXT_CHANNEL_ID));

package/dist/analytics.js

@@ -0,0 +1,238 @@
+// Anonymous product analytics via Strada (OpenTelemetry).
+// Tracks install-level usage only: no Discord IDs, paths, prompts, or secrets.
+// A random install id is stored in {dataDir}/install-id for DAU-style queries.
+//
+// Metrics are "active installs", not people. Multiple --data-dir values count
+// as separate installs. Query with ServiceName = 'kimaki-cli' and
+// LogAttributes['custom.install_id'] / LogAttributes['event.name'].
+import fs from 'node:fs';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { createRequire } from 'node:module';
+import { initStrada, track, flush } from '@strada.sh/sdk';
+import { getDataDir } from './config.js';
+import { createLogger, LogPrefix } from './logger.js';
+import { store } from './store.js';
+const logger = createLogger(LogPrefix.CLI);
+// Public Strada project for production kimaki usage (write-only ingest token).
+// Override with KIMAKI_STRADA_* for local/dev against kimaki-local.
+// Disable with --no-analytics or KIMAKI_STRADA_ENABLED=0.
+const DEFAULT_STRADA_PROJECT_ID = '01KYX3X6FEBBV5JV6Q8M97988C';
+const DEFAULT_STRADA_TOKEN = 'str_9eee60d24a444da78107f8780fe965c5f8cae422def44dcb9ee94d8035a5a14f';
+const INSTALL_ID_FILENAME = 'install-id';
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+const SCHEMA_VERSION = 1;
+const INSTALL_ID_FILENAME_EXPORT = INSTALL_ID_FILENAME;
+let initialized = false;
+let identityFailed = false;
+let installIdCache = null;
+let botModeOverride = null;
+/** Captured events when tests call _enableAnalyticsTestCapture(). */
+let testCapture = null;
+function isAnalyticsDisabled() {
+    if (testCapture)
+        return false;
+    if (process.env.KIMAKI_VITEST)
+        return true;
+    if (process.env.KIMAKI_STRADA_ENABLED === '0')
+        return true;
+    if (process.env.KIMAKI_STRADA_ENABLED === 'false')
+        return true;
+    return false;
+}
+function getKimakiVersion() {
+    const require = createRequire(import.meta.url);
+    const pkg = require('../package.json');
+    return pkg.version;
+}
+function isValidInstallId(value) {
+    return UUID_RE.test(value);
+}
+function resolveBotMode() {
+    if (botModeOverride)
+        return botModeOverride;
+    if (store.getState().discordBaseUrl !== 'https://discord.com') {
+        return 'gateway';
+    }
+    return 'self_hosted';
+}
+/**
+ * Set bot mode once credentials are known (gateway vs self-hosted).
+ * Applied as a common property on every subsequent event.
+ */
+export function setAnalyticsBotMode(mode) {
+    botModeOverride = mode;
+}
+/**
+ * Stable anonymous id for this data dir. Created once and reused forever.
+ * Returns null when the id cannot be read or persisted (fail closed).
+ */
+export function getInstallId() {
+    if (identityFailed)
+        return null;
+    if (installIdCache)
+        return installIdCache;
+    const filePath = path.join(getDataDir(), INSTALL_ID_FILENAME);
+    const existing = (() => {
+        try {
+            if (!fs.existsSync(filePath))
+                return null;
+            const value = fs.readFileSync(filePath, 'utf8').trim();
+            if (!value || !isValidInstallId(value))
+                return null;
+            return value;
+        }
+        catch {
+            return null;
+        }
+    })();
+    if (existing) {
+        installIdCache = existing;
+        return existing;
+    }
+    const id = crypto.randomUUID();
+    try {
+        fs.mkdirSync(path.dirname(filePath), { recursive: true });
+        // Use plain write so a corrupt/non-uuid file is replaced. Concurrent
+        // writers may race; we re-read and only accept a valid uuid afterward.
+        fs.writeFileSync(filePath, `${id}\n`, { encoding: 'utf8' });
+        const verified = fs.readFileSync(filePath, 'utf8').trim();
+        if (!isValidInstallId(verified)) {
+            identityFailed = true;
+            logger.warn('analytics disabled: install-id file is not a valid uuid');
+            return null;
+        }
+        installIdCache = verified;
+        return verified;
+    }
+    catch {
+        identityFailed = true;
+        logger.warn('analytics disabled: could not persist install-id (data dir not writable?)');
+        return null;
+    }
+}
+/** Common low-cardinality props on every product event. */
+export function commonAnalyticsProps(extra) {
+    const installId = getInstallId();
+    if (!installId)
+        return null;
+    return {
+        ...(extra ?? {}),
+        install_id: installId,
+        schema_version: SCHEMA_VERSION,
+        bot_mode: resolveBotMode(),
+        platform: process.platform,
+        arch: process.arch,
+    };
+}
+/**
+ * Initialize Strada. Safe to call once from the bot or short-lived CLI paths
+ * that emit product events. No-ops under tests and when disabled.
+ */
+export function initAnalytics() {
+    if (initialized)
+        return;
+    if (isAnalyticsDisabled() && !testCapture) {
+        initialized = true;
+        return;
+    }
+    if (testCapture) {
+        initialized = true;
+        return;
+    }
+    const installId = getInstallId();
+    if (!installId) {
+        initialized = true;
+        return;
+    }
+    const projectId = process.env.KIMAKI_STRADA_PROJECT_ID || DEFAULT_STRADA_PROJECT_ID;
+    const token = process.env.KIMAKI_STRADA_TOKEN || DEFAULT_STRADA_TOKEN;
+    const environment = process.env.KIMAKI_STRADA_ENVIRONMENT ||
+        process.env.NODE_ENV ||
+        'production';
+    try {
+        initStrada({
+            projectId,
+            token,
+            service: 'kimaki-cli',
+            environment,
+            version: getKimakiVersion(),
+            userId: installId,
+        });
+        initialized = true;
+    }
+    catch (error) {
+        logger.warn('Failed to init analytics:', error instanceof Error ? error.message : String(error));
+        initialized = true;
+    }
+}
+/**
+ * Fire-and-forget product event. Never throws.
+ * install_id / schema_version / bot_mode / platform / arch always win over
+ * caller props so identity invariants cannot be overridden.
+ */
+export function trackEvent(name, properties) {
+    if (!initialized && !testCapture)
+        return;
+    if (isAnalyticsDisabled() && !testCapture)
+        return;
+    if (identityFailed)
+        return;
+    const props = commonAnalyticsProps(properties);
+    if (!props)
+        return;
+    if (testCapture) {
+        testCapture.push({ name, properties: props });
+        return;
+    }
+    try {
+        track(name, props);
+    }
+    catch (error) {
+        logger.warn(`trackEvent(${name}) failed:`, error instanceof Error ? error.message : String(error));
+    }
+}
+/**
+ * Flush buffered telemetry. Call before process.exit on short CLI paths and
+ * on graceful bot shutdown.
+ */
+export async function flushAnalytics() {
+    if (testCapture)
+        return;
+    if (!initialized || isAnalyticsDisabled() || identityFailed)
+        return;
+    try {
+        await flush();
+    }
+    catch (error) {
+        logger.warn('flushAnalytics failed:', error instanceof Error ? error.message : String(error));
+    }
+}
+/** @deprecated Use commonAnalyticsProps / trackEvent common fields. */
+export function baseRuntimeProps(extra) {
+    return {
+        version: getKimakiVersion(),
+        ...extra,
+    };
+}
+/** Test helper: reset module state between unit tests. */
+export function _resetAnalyticsForTests() {
+    initialized = false;
+    identityFailed = false;
+    installIdCache = null;
+    botModeOverride = null;
+    testCapture = null;
+}
+/**
+ * Test helper: enable in-process event capture instead of Strada export.
+ * Returns the mutable capture array.
+ */
+export function _enableAnalyticsTestCapture(opts) {
+    testCapture = [];
+    initialized = true;
+    identityFailed = false;
+    installIdCache = opts?.installId ?? '11111111-1111-4111-8111-111111111111';
+    botModeOverride = opts?.botMode ?? 'self_hosted';
+    return testCapture;
+}
+export { INSTALL_ID_FILENAME_EXPORT as INSTALL_ID_FILENAME };

package/dist/analytics.test.js

@@ -0,0 +1,130 @@
+// Unit tests for anonymous install id and product event construction.
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { setDataDir } from './config.js';
+import { _enableAnalyticsTestCapture, _resetAnalyticsForTests, commonAnalyticsProps, getInstallId, initAnalytics, INSTALL_ID_FILENAME, setAnalyticsBotMode, trackEvent, } from './analytics.js';
+describe('analytics', () => {
+    let tmpDir;
+    beforeEach(() => {
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'kimaki-analytics-'));
+        setDataDir(tmpDir);
+        _resetAnalyticsForTests();
+    });
+    afterEach(() => {
+        _resetAnalyticsForTests();
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+    it('creates and reuses install-id', () => {
+        const first = getInstallId();
+        expect(first).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i);
+        expect(fs.readFileSync(path.join(tmpDir, INSTALL_ID_FILENAME), 'utf8').trim()).toBe(first);
+        _resetAnalyticsForTests();
+        setDataDir(tmpDir);
+        expect(getInstallId()).toBe(first);
+    });
+    it('replaces invalid install-id file contents', () => {
+        fs.writeFileSync(path.join(tmpDir, INSTALL_ID_FILENAME), 'not-a-uuid\n');
+        const id = getInstallId();
+        expect(id).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i);
+        expect(id).not.toBe('not-a-uuid');
+        expect(fs.readFileSync(path.join(tmpDir, INSTALL_ID_FILENAME), 'utf8').trim()).toBe(id);
+    });
+    it('no-ops trackEvent under vitest without capture', () => {
+        initAnalytics();
+        expect(() => {
+            trackEvent('bot_started', { guild_count: 1 });
+        }).not.toThrow();
+    });
+    it('KIMAKI_STRADA_ENABLED=0 keeps initAnalytics from throwing', () => {
+        const prev = process.env.KIMAKI_STRADA_ENABLED;
+        process.env.KIMAKI_STRADA_ENABLED = '0';
+        try {
+            initAnalytics();
+            expect(() => {
+                trackEvent('bot_started', { guild_count: 1 });
+            }).not.toThrow();
+        }
+        finally {
+            if (prev === undefined) {
+                delete process.env.KIMAKI_STRADA_ENABLED;
+            }
+            else {
+                process.env.KIMAKI_STRADA_ENABLED = prev;
+            }
+        }
+    });
+    it('builds common props and install_id always wins', () => {
+        setAnalyticsBotMode('gateway');
+        const captured = _enableAnalyticsTestCapture({
+            installId: '22222222-2222-4222-8222-222222222222',
+            botMode: 'gateway',
+        });
+        trackEvent('turn_started', {
+            install_id: 'should-not-win',
+            input_kind: 'prompt',
+            ingress_mode: 'direct',
+            source: 'discord',
+            uses_custom_agent: false,
+        });
+        expect(captured).toHaveLength(1);
+        expect(captured[0].name).toBe('turn_started');
+        expect(captured[0].properties).toMatchObject({
+            install_id: '22222222-2222-4222-8222-222222222222',
+            schema_version: 1,
+            bot_mode: 'gateway',
+            platform: process.platform,
+            arch: process.arch,
+            input_kind: 'prompt',
+            ingress_mode: 'direct',
+            source: 'discord',
+            uses_custom_agent: false,
+        });
+        expect(captured[0].properties.install_id).not.toBe('should-not-win');
+        const common = commonAnalyticsProps({ foo: 'bar' });
+        expect(common).toMatchObject({
+            foo: 'bar',
+            install_id: '22222222-2222-4222-8222-222222222222',
+            schema_version: 1,
+            bot_mode: 'gateway',
+        });
+    });
+    it('emits project_registered session_created turn_completed shapes', () => {
+        const captured = _enableAnalyticsTestCapture({
+            installId: '33333333-3333-4333-8333-333333333333',
+            botMode: 'self_hosted',
+        });
+        trackEvent('project_registered', {
+            project_kind: 'user',
+            source: 'cli',
+            user_project_count: 2,
+        });
+        trackEvent('session_created', {
+            has_worktree: true,
+            source: 'discord',
+        });
+        trackEvent('turn_completed', {
+            duration_sec: 42,
+        });
+        expect(captured.map((e) => e.name)).toEqual([
+            'project_registered',
+            'session_created',
+            'turn_completed',
+        ]);
+        expect(captured[0].properties).toMatchObject({
+            project_kind: 'user',
+            source: 'cli',
+            user_project_count: 2,
+            install_id: '33333333-3333-4333-8333-333333333333',
+            schema_version: 1,
+        });
+        expect(captured[1].properties).toMatchObject({
+            has_worktree: true,
+            source: 'discord',
+        });
+        expect(captured[2].properties).toMatchObject({
+            duration_sec: 42,
+        });
+    });
+});

package/dist/channel-management.js

@@ -4,10 +4,40 @@
 import { ChannelType, } from 'discord.js';
 import fs from 'node:fs';
 import path from 'node:path';
-import { getChannelDirectory, setChannelDirectory, findChannelsByDirectory, } from './database.js';
+import { getChannelDirectory, setChannelDirectory, findChannelsByDirectory, listTrackedTextChannels, } from './database.js';
 import { getProjectsDir } from './config.js';
 import { execAsync } from './worktrees.js';
 import { createLogger, LogPrefix } from './logger.js';
+import { trackEvent, } from './analytics.js';
+/**
+ * Distinct non-default project directories mapped as text channels.
+ * Returns null on query failure so callers omit the field instead of
+ * emitting a fabricated zero.
+ */
+export async function getUserProjectCount() {
+    try {
+        const channels = await listTrackedTextChannels();
+        const defaultDir = path.resolve(getDefaultKimakiDirectory());
+        const dirs = new Set(channels
+            .map((row) => path.resolve(row.directory))
+            .filter((directory) => directory !== defaultDir));
+        return dirs.size;
+    }
+    catch {
+        return null;
+    }
+}
+async function trackProjectRegistered({ projectKind, source, }) {
+    const userProjectCount = await getUserProjectCount();
+    const props = {
+        project_kind: projectKind,
+        source,
+    };
+    if (userProjectCount !== null) {
+        props.user_project_count = userProjectCount;
+    }
+    trackEvent('project_registered', props);
+}
 const logger = createLogger(LogPrefix.CHANNEL);
 export async function ensureKimakiCategory(guild, botName) {
     // Skip appending bot name if it's already "kimaki" to avoid "Kimaki kimaki"
@@ -45,7 +75,7 @@ export async function ensureKimakiAudioCategory(guild, botName) {
         type: ChannelType.GuildCategory,
     });
 }
-export async function createProjectChannels({ guild, projectDirectory, botName, enableVoiceChannels = false, }) {
+export async function createProjectChannels({ guild, projectDirectory, botName, enableVoiceChannels = false, analyticsSource = 'cli', }) {
     const baseName = path.basename(projectDirectory);
     const channelName = `${baseName}`
         .toLowerCase()
@@ -63,6 +93,10 @@ export async function createProjectChannels({ guild, projectDirectory, botName,
         directory: projectDirectory,
         channelType: 'text',
     });
+    await trackProjectRegistered({
+        projectKind: 'user',
+        source: analyticsSource,
+    });
     let voiceChannelId = null;
     if (enableVoiceChannels) {
         const kimakiAudioCategory = await ensureKimakiAudioCategory(guild, botName);
@@ -237,6 +271,10 @@ export async function createDefaultKimakiChannel({ guild, botName, appId, isGate
         channelType: 'text',
         guildId: guild.id,
     });
+    await trackProjectRegistered({
+        projectKind: 'default',
+        source: 'onboarding',
+    });
     logger.log(`Created default kimaki channel: #${channelName} (${textChannel.id})`);
     return {
         textChannel,

package/dist/cli-commands/project.js

@@ -25,6 +25,7 @@ import { execAsync, validateWorktreeDirectory } from '../worktrees.js';
 import { upgrade, getCurrentVersion } from '../upgrade.js';
 import { getPromptPreview, parseSendAtValue, parseScheduledTaskPayload, serializeScheduledTaskPayload } from '../task-schedule.js';
 import { EXIT_NO_RESTART, formatMemberLookupUnavailableMessage, formatRelativeTime, formatTaskScheduleLine, isDiscordMemberLookupUnavailable, isGuildMemberSearchResult, isThreadChannelType, printDiscordInstallUrlAndExit, resolveBotCredentials, resolveDiscordUserOption, sendDiscordMessageWithOptionalAttachment, } from '../cli-runner.js';
+import { flushAnalytics, initAnalytics, setAnalyticsBotMode, } from '../analytics.js';
 const cliLogger = createLogger(LogPrefix.CLI);
 const cli = goke();
 cli
@@ -43,6 +44,9 @@ cli
     const { token: botToken, appId } = await resolveBotCredentials({
         appIdOverride: options.appId,
     });
+    const botRow = await getBotTokenWithMode();
+    setAnalyticsBotMode(botRow?.mode === 'gateway' ? 'gateway' : 'self_hosted');
+    initAnalytics();
     if (!appId) {
         cliLogger.error('App ID is required to create channels. Use --app-id or run `kimaki` first.');
         process.exit(EXIT_NO_RESTART);
@@ -86,6 +90,7 @@ cli
         guild,
         projectDirectory: absolutePath,
         botName: client.user?.username,
+        analyticsSource: 'cli',
     });
     void client.destroy();
     if (textChannelId || voiceChannelId) {
@@ -94,6 +99,7 @@ cli
     const channelUrl = `https://discord.com/channels/${guild.id}/${textChannelId}`;
     note(`Created channels for project:\n\n📝 Text: #${channelName}\n🔊 Voice: #${channelName}\n📁 Directory: ${absolutePath}\n\nURL: ${channelUrl}`, '✅ Success');
     cliLogger.log(channelUrl);
+    await flushAnalytics();
     process.exit(0);
 });
 cli
@@ -393,6 +399,8 @@ cli
         process.exit(EXIT_NO_RESTART);
     }
     const { token: botToken } = botRow;
+    setAnalyticsBotMode(botRow.mode === 'gateway' ? 'gateway' : 'self_hosted');
+    initAnalytics();
     const projectsDir = getProjectsDir();
     const projectDirectory = path.join(projectsDir, sanitizedName);
     if (!fs.existsSync(projectsDir)) {
@@ -420,11 +428,13 @@ cli
         guild,
         projectDirectory,
         botName: client.user?.username,
+        analyticsSource: 'cli',
     });
     void client.destroy();
     const channelUrl = `https://discord.com/channels/${guild.id}/${textChannelId}`;
     note(`Created project: ${sanitizedName}\n\nDirectory: ${projectDirectory}\nChannel: #${channelName}\nURL: ${channelUrl}`, '✅ Success');
     cliLogger.log(channelUrl);
+    await flushAnalytics();
     process.exit(0);
 });
 // Resolve the guild for project add/create commands. In gateway mode the