runwork 0.6.2 → 0.8.2

package/dist/commands/__tests__/upgrade.test.js

@@ -0,0 +1,174 @@
+/**
+ * Tests for `runwork upgrade`.
+ *
+ * The module under test has top-level side effects (it builds a Commander
+ * command and captures fetch/process references), so we exercise the exported
+ * __internal helpers against a local HTTP server that serves a fake
+ * /cli/latest.json.
+ */
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { createServer } from 'node:http';
+import { __internal } from '../upgrade.js';
+function startJsonServer(body, status = 200) {
+    return new Promise((resolvePromise) => {
+        const server = createServer((req, res) => {
+            if (req.url === '/cli/latest.json') {
+                if (body === null) {
+                    res.writeHead(status, { 'Content-Type': 'application/json' });
+                    res.end('{"error": "not found"}');
+                    return;
+                }
+                res.writeHead(status, {
+                    'Content-Type': 'application/json; charset=utf-8',
+                });
+                res.end(JSON.stringify(body));
+                return;
+            }
+            res.writeHead(404);
+            res.end('not found');
+        });
+        server.listen(0, '127.0.0.1', () => {
+            const addr = server.address();
+            if (addr && typeof addr === 'object') {
+                const url = `http://127.0.0.1:${addr.port}`;
+                const stop = () => new Promise((resolveStop) => {
+                    server.close(() => resolveStop());
+                });
+                resolvePromise({ url, stop });
+            }
+        });
+    });
+}
+describe('__internal.fetchLatestVersion', () => {
+    let originalBase;
+    let originalFetch;
+    let serverStop = null;
+    beforeEach(() => {
+        originalBase = process.env.RUNWORK_DOWNLOAD_BASE_URL;
+        originalFetch = globalThis.fetch;
+    });
+    afterEach(async () => {
+        if (serverStop)
+            await serverStop();
+        serverStop = null;
+        globalThis.fetch = originalFetch;
+        if (originalBase === undefined)
+            delete process.env.RUNWORK_DOWNLOAD_BASE_URL;
+        else
+            process.env.RUNWORK_DOWNLOAD_BASE_URL = originalBase;
+    });
+    it('parses the version field from a valid manifest', async () => {
+        const server = await startJsonServer({
+            name: 'runwork',
+            version: '1.2.3',
+            publishedAt: '2026-04-14T00:00:00Z',
+            artifacts: {},
+        });
+        serverStop = server.stop;
+        // Override fetch URL by intercepting via globalThis.fetch
+        const realFetch = globalThis.fetch;
+        globalThis.fetch = ((input, init) => {
+            const url = typeof input === 'string' ? input : input.toString();
+            if (url === __internal.LATEST_JSON_URL) {
+                return realFetch(`${server.url}/cli/latest.json`, init);
+            }
+            return realFetch(input, init);
+        });
+        const version = await __internal.fetchLatestVersion();
+        expect(version).toBe('1.2.3');
+    });
+    it('strips a leading v from the version', async () => {
+        const server = await startJsonServer({ version: 'v9.9.9' });
+        serverStop = server.stop;
+        const realFetch = globalThis.fetch;
+        globalThis.fetch = ((input, init) => {
+            const url = typeof input === 'string' ? input : input.toString();
+            if (url === __internal.LATEST_JSON_URL) {
+                return realFetch(`${server.url}/cli/latest.json`, init);
+            }
+            return realFetch(input, init);
+        });
+        const version = await __internal.fetchLatestVersion();
+        expect(version).toBe('9.9.9');
+    });
+    it('returns null on HTTP error', async () => {
+        const server = await startJsonServer(null, 500);
+        serverStop = server.stop;
+        const realFetch = globalThis.fetch;
+        globalThis.fetch = ((input, init) => {
+            const url = typeof input === 'string' ? input : input.toString();
+            if (url === __internal.LATEST_JSON_URL) {
+                return realFetch(`${server.url}/cli/latest.json`, init);
+            }
+            return realFetch(input, init);
+        });
+        const version = await __internal.fetchLatestVersion();
+        expect(version).toBeNull();
+    });
+    it('returns null when fetch throws', async () => {
+        globalThis.fetch = (() => {
+            throw new Error('network down');
+        });
+        const version = await __internal.fetchLatestVersion();
+        expect(version).toBeNull();
+    });
+    it('returns null when the manifest has no version field', async () => {
+        const server = await startJsonServer({ name: 'runwork' });
+        serverStop = server.stop;
+        const realFetch = globalThis.fetch;
+        globalThis.fetch = ((input, init) => {
+            const url = typeof input === 'string' ? input : input.toString();
+            if (url === __internal.LATEST_JSON_URL) {
+                return realFetch(`${server.url}/cli/latest.json`, init);
+            }
+            return realFetch(input, init);
+        });
+        const version = await __internal.fetchLatestVersion();
+        expect(version).toBeNull();
+    });
+});
+describe('__internal endpoint constants', () => {
+    it('all endpoints live on runwork.ai', () => {
+        expect(__internal.BASE_URL).toBe('https://runwork.ai');
+        expect(__internal.LATEST_JSON_URL).toBe('https://runwork.ai/cli/latest.json');
+        expect(__internal.INSTALL_SH_URL).toBe('https://runwork.ai/install.sh');
+        expect(__internal.INSTALL_PS1_URL).toBe('https://runwork.ai/install.ps1');
+    });
+    it('does not reference api.github.com or github.com/.../releases', () => {
+        const values = Object.values(__internal).filter((v) => typeof v === 'string');
+        for (const v of values) {
+            expect(v).not.toContain('api.github.com');
+            expect(v).not.toContain('/releases');
+        }
+    });
+});
+describe('__internal.detectInstallMethod', () => {
+    const originalArgv1 = process.argv[1];
+    afterEach(() => {
+        process.argv[1] = originalArgv1;
+    });
+    it('detects homebrew installs', () => {
+        process.argv[1] = '/opt/homebrew/Cellar/runwork/0.6.2/bin/runwork';
+        expect(__internal.detectInstallMethod()).toBe('brew');
+    });
+    it('detects bun global installs', () => {
+        process.argv[1] = '/Users/user/.bun/install/global/node_modules/runwork/bin/runwork.js';
+        expect(__internal.detectInstallMethod()).toBe('bun');
+    });
+    it('detects pnpm global installs', () => {
+        process.argv[1] = '/Users/user/.local/share/pnpm/global/5/node_modules/runwork/bin/runwork.js';
+        expect(__internal.detectInstallMethod()).toBe('pnpm');
+    });
+    it('detects yarn global installs', () => {
+        process.argv[1] = '/Users/user/.yarn/bin/runwork';
+        expect(__internal.detectInstallMethod()).toBe('yarn');
+    });
+    it('detects volta installs', () => {
+        process.argv[1] = '/Users/user/.volta/tools/image/packages/runwork/bin/runwork';
+        expect(__internal.detectInstallMethod()).toBe('volta');
+    });
+    it('falls back to binary for standalone paths', () => {
+        process.argv[1] = '/Users/user/.runwork/bin/runwork';
+        expect(__internal.detectInstallMethod()).toBe('binary');
+    });
+});

package/dist/commands/build-plugin.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const buildPluginCommand: Command;

package/dist/commands/build-plugin.js

@@ -0,0 +1,135 @@
+import { Command } from 'commander';
+import { existsSync, readFileSync } from 'fs';
+import { resolve, join } from 'path';
+import { homedir } from 'os';
+import { requireAuth } from '../auth/store.js';
+import { ApiClient } from '../api/client.js';
+import { getAdapterBySlug } from '../agents/detect.js';
+import { RUNWORK_MCP_PREFIX, RUNWORK_WORKSPACE_MCP_NAME } from '../agents/types.js';
+import { generateIntroSkill, buildAppSkillDescription } from '../agents/intro-skill.js';
+function loadSetupState(filePath) {
+    if (!existsSync(filePath))
+        return null;
+    try {
+        return JSON.parse(readFileSync(filePath, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+export const buildPluginCommand = new Command('build-plugin')
+    .description('Build an installable plugin archive for an agent (e.g. Claude Desktop)')
+    .requiredOption('--agent <slug>', 'Target agent slug (e.g. claude-desktop)')
+    .option('--output <path>', 'Output zip path', 'runwork-plugin.zip')
+    .action(async (opts) => {
+    const adapter = getAdapterBySlug(opts.agent);
+    if (!adapter) {
+        console.error(`Unknown agent: ${opts.agent}`);
+        process.exit(1);
+    }
+    if (!adapter.buildPluginZip) {
+        console.error(`Agent "${adapter.name}" does not support plugin zip build.`);
+        process.exit(1);
+    }
+    const credentials = requireAuth();
+    // Find the first available setup state so we know which workspace to
+    // pull content from. We don't care about project vs user scope here —
+    // plugin archives are always user-scoped for the agent they're uploaded to.
+    const projectStatePath = join(process.cwd(), '.runwork', 'setup.json');
+    const userStatePath = join(homedir(), '.runwork', 'setup.json');
+    const state = loadSetupState(projectStatePath) ?? loadSetupState(userStatePath);
+    if (!state) {
+        console.error('No setup state found. Run `runwork setup` first.');
+        process.exit(1);
+    }
+    const client = new ApiClient(credentials);
+    // Refresh workspace name/slug if missing or stale (matches sync behavior).
+    if (!state.workspaceName || state.workspaceName === state.workspaceId || !state.workspaceSlug) {
+        try {
+            const workspaces = await client.listWorkspaces();
+            const ws = workspaces.find((w) => w.id === state.workspaceId);
+            if (ws?.name)
+                state.workspaceName = ws.name;
+            if (ws?.slug)
+                state.workspaceSlug = ws.slug;
+        }
+        catch {
+            /* best-effort */
+        }
+    }
+    console.log(`Building plugin for ${adapter.name} from workspace ${state.workspaceName || state.workspaceId}...`);
+    // Fetch the same inputs sync uses. The plugin archive must contain
+    // identical content to what sync would write into the plugin directory,
+    // including workspace team instructions + per-agent extra instructions.
+    const [allSkills, mcpServers, externalSkills, registries, connectedIntegrations, onboardingConfig,] = await Promise.all([
+        client.listWorkspaceSkills(state.workspaceId, true),
+        client.listMcpServers(state.workspaceId),
+        client.listExternalSkills(state.workspaceId),
+        client.getWorkspaceAll(state.workspaceId).catch(() => null),
+        client
+            .listConnectedIntegrations(state.workspaceId)
+            .then((list) => list.map((i) => i.canonicalId ?? i.integrationId))
+            .catch(() => []),
+        client.getOnboardingConfig(state.workspaceId).catch(() => null),
+    ]);
+    const baseUrl = credentials.baseUrl || 'https://runwork.ai';
+    const mcpEntries = mcpServers
+        .filter((s) => s.enabled)
+        .map((s) => ({
+        name: `${RUNWORK_MCP_PREFIX}${s.name}`,
+        url: s.url,
+        transport: s.transport,
+        headers: { Authorization: `Bearer ${credentials.apiKey}` },
+        description: `Runwork MCP server: ${s.name}. Provides tools for interacting with this workspace resource.`,
+    }));
+    mcpEntries.push({
+        name: RUNWORK_WORKSPACE_MCP_NAME,
+        url: `${baseUrl}/api/workspaces/${state.workspaceId}/mcp`,
+        transport: 'streamable-http',
+        headers: { Authorization: `Bearer ${credentials.apiKey}` },
+        description: "Runwork workspace tools: query entities, trigger workflows, manage integrations, run agents, and access shared data across your team's apps.",
+    });
+    const remoteSkills = [];
+    for (const s of externalSkills) {
+        remoteSkills.push({ name: s.name, content: s.content, source: 'external' });
+    }
+    for (const s of allSkills) {
+        if (s.type === 'app' && s.appId && s.content?.trim()) {
+            remoteSkills.push({ name: s.name, content: s.content, source: 'app', appId: s.appId });
+        }
+    }
+    const introSkill = generateIntroSkill({
+        workspaceName: state.workspaceName || state.workspaceId,
+        workspaceId: state.workspaceId,
+        workspaceSlug: state.workspaceSlug,
+        registries,
+        connectedIntegrations,
+        mcpServerCount: mcpEntries.length,
+        skillCount: remoteSkills.length,
+        mcpServerNames: mcpEntries.map((e) => e.name.replace(RUNWORK_MCP_PREFIX, '')),
+        skillNames: remoteSkills.map((s) => s.name),
+    });
+    // When the adapter exposes skills through MCP already, skip duplicating
+    // app skills into the plugin — same rule sync applies per-adapter.
+    const skipAppSkills = adapter.mcpProvidesSkills && mcpEntries.length > 0;
+    const skillFiles = [
+        introSkill,
+        ...remoteSkills
+            .filter((s) => !(skipAppSkills && s.source === 'app'))
+            .map((s) => ({
+            name: s.name,
+            filename: s.name.toLowerCase().replace(/[^a-z0-9]+/g, '-'),
+            content: s.content,
+            description: s.source === 'app'
+                ? buildAppSkillDescription(s.name, registries) || `${s.name} - Runwork workspace application`
+                : `${s.name} - Runwork workspace skill`,
+        })),
+    ];
+    // Merge team instructions + per-agent extra instructions (same rule as sync).
+    const teamInstructions = onboardingConfig?.config?.teamInstructions;
+    const agentExtra = onboardingConfig?.config?.agentConfigs?.[adapter.slug]?.extraInstructions;
+    const mergedInstructions = [teamInstructions, agentExtra].filter(Boolean).join('\n\n') || null;
+    const outputPath = resolve(opts.output);
+    await adapter.buildPluginZip(skillFiles, mcpEntries, mergedInstructions, outputPath);
+    console.log(`Wrote ${outputPath}`);
+});

package/dist/commands/init.d.ts

@@ -9,7 +9,13 @@ export interface InitResult {
     workspaceId: string;
     workspaceName: string;
 }
-export declare function execInit(client: ApiClient, appName: string, workspace: WorkspaceInfo): Promise<InitResult>;
+export interface ExecInitOptions {
+    /** When true, create the app in cwd/<slug> instead of ~/.runwork/<slug>. */
+    here?: boolean;
+}
+/** Default parent directory for new apps when --here is not passed. */
+export declare const DEFAULT_APPS_DIR: string;
+export declare function execInit(client: ApiClient, appName: string, workspace: WorkspaceInfo, options?: ExecInitOptions): Promise<InitResult>;
 /** Full create flow: prompt for name/workspace, init, and run agent wizard */
-export declare function runCreateFlow(name?: string, workspaceFlag?: string): Promise<void>;
+export declare function runCreateFlow(name?: string, workspaceFlag?: string, options?: ExecInitOptions): Promise<void>;
 export declare const initCommand: Command;

package/dist/commands/init.js

@@ -2,6 +2,7 @@ import { Command } from 'commander';
 import { execFileSync } from 'child_process';
 import { writeFileSync, existsSync, mkdirSync } from 'fs';
 import { join, resolve } from 'path';
+import { homedir } from 'os';
 import { requireAuth } from '../auth/store.js';
 import { ApiClient } from '../api/client.js';
 import { promptSelect, promptInput } from '../utils/prompt.js';
@@ -12,15 +13,25 @@ import { removeNestedGitDirs } from '../utils/fs.js';
 import { runAgentWizard } from '../ui/banner.js';
 import { shouldOutputJson, jsonOut } from '../utils/output.js';
 import { buildInitGuide, buildErrorResponse } from '../utils/agent-guidance.js';
-export async function execInit(client, appName, workspace) {
+/** Default parent directory for new apps when --here is not passed. */
+export const DEFAULT_APPS_DIR = join(homedir(), '.runwork', 'apps');
+export async function execInit(client, appName, workspace, options = {}) {
     const app = await client.initApp(workspace.id, appName);
     const slug = app.slug || appName.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
-    const dir = slug;
+    const parentDir = options.here ? process.cwd() : DEFAULT_APPS_DIR;
+    if (!options.here && !existsSync(parentDir)) {
+        mkdirSync(parentDir, { recursive: true });
+    }
+    const dir = join(parentDir, slug);
     if (existsSync(dir)) {
         console.error(`Directory "${dir}" already exists.`);
         process.exit(1);
     }
     mkdirSync(dir, { recursive: true });
+    if (!options.here) {
+        console.log(`Creating app in ${dir}`);
+        console.log('(Pass --here to scaffold in the current directory instead.)');
+    }
     // Download and extract skeleton template first
     console.log('Downloading project template...');
     try {
@@ -68,7 +79,7 @@ export async function execInit(client, appName, workspace) {
         // Nothing to commit is fine
     }
     execFileSync('git', ['push', '-u', 'runwork', 'main'], { cwd: dir, stdio: 'pipe' });
-    console.log(`\nApp "${app.name}" initialized in ${dir}/`);
+    console.log(`\nApp "${app.name}" initialized in ${dir}`);
     return {
         appId: app.id,
         appName: app.name,
@@ -79,7 +90,7 @@ export async function execInit(client, appName, workspace) {
     };
 }
 /** Full create flow: prompt for name/workspace, init, and run agent wizard */
-export async function runCreateFlow(name, workspaceFlag) {
+export async function runCreateFlow(name, workspaceFlag, options = {}) {
     const useJson = shouldOutputJson(undefined);
     const creds = requireAuth();
     const client = new ApiClient(creds);
@@ -117,13 +128,13 @@ export async function runCreateFlow(name, workspaceFlag) {
     if (!useJson) {
         console.log(`Creating "${appName}" in workspace "${workspace.name}"...`);
     }
-    const initResult = await execInit(client, appName, workspace);
+    const initResult = await execInit(client, appName, workspace, options);
     if (useJson) {
         const response = {
             success: true,
             command: 'init',
             result: initResult,
-            guide: buildInitGuide(initResult.appName, initResult.slug),
+            guide: buildInitGuide(initResult.appName, initResult.directory),
         };
         jsonOut(response);
         return;
@@ -135,6 +146,7 @@ export const initCommand = new Command('init')
     .description('Create a new Runwork app')
     .argument('[name]', 'App name')
     .option('--workspace <name-or-id>', 'Workspace name or ID (skips interactive selection)')
+    .option('--here', `Scaffold in the current directory instead of ${DEFAULT_APPS_DIR}/<slug>`)
     .action(async (name, options) => {
-    await runCreateFlow(name, options?.workspace);
+    await runCreateFlow(name, options?.workspace, { here: options?.here });
 });

package/dist/commands/sync-telemetry.d.ts

@@ -0,0 +1,33 @@
+import type { AgentAdapter, AgentUsageStats, SkillUsageEntry } from '../agents/types.js';
+import type { SetupState } from '../types.js';
+export interface TelemetryEvent {
+    eventType: string;
+    agentSlug?: string;
+    metadata?: Record<string, unknown>;
+    timestamp: string;
+}
+export interface TelemetryAdapterResult {
+    slug: string;
+    name: string;
+    stats: AgentUsageStats | null | 'unsupported';
+    skills: SkillUsageEntry[] | null | 'unsupported';
+    error?: string;
+}
+export interface TelemetryCollection {
+    events: TelemetryEvent[];
+    adapterResults: TelemetryAdapterResult[];
+    newlyReportedAgents: string[];
+    healthReported: boolean;
+}
+export interface CollectTelemetryParams {
+    adapters: AgentAdapter[];
+    state: SetupState;
+    syncedSkillsCount: number;
+    syncedMcpServersCount: number;
+    teamInstructionsApplied: boolean;
+    agentConfigsApplied: number;
+    now?: string;
+}
+export declare function collectTelemetryEvents(params: CollectTelemetryParams): Promise<TelemetryCollection>;
+export declare function printTelemetryVerbose(result: TelemetryCollection): void;
+export declare function summarizeTelemetryForDryRun(result: TelemetryCollection): string;

package/dist/commands/sync-telemetry.js

@@ -0,0 +1,186 @@
+export async function collectTelemetryEvents(params) {
+    const now = params.now ?? new Date().toISOString();
+    const events = [];
+    const adapterResults = [];
+    const previouslyReported = new Set(params.state.reportedAgentSlugs ?? []);
+    const newlyReportedAgents = [];
+    for (const slug of params.state.configuredAgents) {
+        if (!previouslyReported.has(slug)) {
+            events.push({
+                eventType: 'local_agent.detected',
+                agentSlug: slug,
+                metadata: { installed: true },
+                timestamp: now,
+            });
+            newlyReportedAgents.push(slug);
+        }
+    }
+    for (const adapter of params.adapters) {
+        let stats = 'unsupported';
+        let skills = 'unsupported';
+        let error;
+        if (adapter.readUsageStats) {
+            try {
+                stats = await adapter.readUsageStats(params.state.lastSyncAt ?? null);
+                if (stats && stats.hasNewActivity) {
+                    events.push({
+                        eventType: 'local_agent.usage',
+                        agentSlug: adapter.slug,
+                        metadata: {
+                            sessionCount: stats.sessionCount,
+                            messageCount: stats.messageCount,
+                            toolCallCount: stats.toolCallCount,
+                            tokensUsed: stats.tokensUsed,
+                            aiLinesAdded: stats.aiLinesAdded,
+                            aiLinesRemoved: stats.aiLinesRemoved,
+                            lastActiveAt: stats.lastActiveAt,
+                            modelsUsed: stats.modelsUsed,
+                            mcpToolCount: stats.mcpToolCount,
+                            ...stats.extra,
+                        },
+                        timestamp: now,
+                    });
+                }
+            }
+            catch (err) {
+                error = err instanceof Error ? err.message : String(err);
+                stats = null;
+            }
+        }
+        if (adapter.readSkillUsage) {
+            try {
+                skills = await adapter.readSkillUsage(params.state.lastSyncAt ?? null);
+                if (skills && skills.length > 0) {
+                    for (const entry of skills) {
+                        events.push({
+                            eventType: 'local_agent.skill_used',
+                            agentSlug: adapter.slug,
+                            metadata: {
+                                skillName: entry.skillName,
+                                count: entry.count,
+                                lastUsedAt: entry.lastUsedAt,
+                            },
+                            timestamp: now,
+                        });
+                    }
+                }
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                error = error ? `${error}; skills: ${msg}` : `skills: ${msg}`;
+                skills = null;
+            }
+        }
+        adapterResults.push({
+            slug: adapter.slug,
+            name: adapter.name,
+            stats,
+            skills,
+            error,
+        });
+    }
+    const lastHealthReport = params.state.lastHealthReportAt
+        ? new Date(params.state.lastHealthReportAt)
+        : null;
+    const shouldReportHealth = !lastHealthReport ||
+        Date.now() - lastHealthReport.getTime() > 24 * 60 * 60 * 1000;
+    let healthReported = false;
+    if (shouldReportHealth) {
+        for (const adapter of params.adapters) {
+            try {
+                const version = await adapter.readVersion?.();
+                events.push({
+                    eventType: 'local_agent.health',
+                    agentSlug: adapter.slug,
+                    metadata: {
+                        version,
+                        installed: true,
+                        platform: process.platform,
+                        arch: process.arch,
+                    },
+                    timestamp: now,
+                });
+            }
+            catch {
+                // Health reporting is best-effort
+            }
+        }
+        healthReported = true;
+    }
+    events.push({
+        eventType: 'local_agent.sync_completed',
+        metadata: {
+            syncedSkills: params.syncedSkillsCount,
+            syncedMcpServers: params.syncedMcpServersCount,
+            teamInstructionsApplied: params.teamInstructionsApplied,
+            agentConfigsApplied: params.agentConfigsApplied,
+        },
+        timestamp: now,
+    });
+    return { events, adapterResults, newlyReportedAgents, healthReported };
+}
+function formatStatsLine(stats) {
+    const parts = [];
+    parts.push(`${stats.sessionCount} session${stats.sessionCount === 1 ? '' : 's'}`);
+    if (stats.messageCount)
+        parts.push(`${stats.messageCount} msgs`);
+    if (stats.toolCallCount)
+        parts.push(`${stats.toolCallCount} tool calls`);
+    if (stats.tokensUsed)
+        parts.push(`${stats.tokensUsed} tokens`);
+    if (stats.aiLinesAdded || stats.aiLinesRemoved) {
+        parts.push(`+${stats.aiLinesAdded}/-${stats.aiLinesRemoved} lines`);
+    }
+    if (stats.mcpToolCount)
+        parts.push(`${stats.mcpToolCount} mcp tools`);
+    if (stats.modelsUsed && stats.modelsUsed.length > 0) {
+        parts.push(`models: ${stats.modelsUsed.join(',')}`);
+    }
+    if (stats.lastActiveAt)
+        parts.push(`last ${stats.lastActiveAt}`);
+    return parts.join(', ');
+}
+export function printTelemetryVerbose(result) {
+    console.log('\n  Telemetry collection:');
+    for (const r of result.adapterResults) {
+        let statsLabel;
+        if (r.stats === 'unsupported') {
+            statsLabel = 'no stats reader';
+        }
+        else if (r.stats === null || !r.stats.hasNewActivity) {
+            statsLabel = 'no new activity';
+        }
+        else {
+            statsLabel = formatStatsLine(r.stats);
+        }
+        let skillsLabel;
+        if (r.skills === 'unsupported') {
+            skillsLabel = 'no skill reader';
+        }
+        else if (r.skills === null || r.skills.length === 0) {
+            skillsLabel = 'none';
+        }
+        else {
+            skillsLabel = `${r.skills.length} skill${r.skills.length === 1 ? '' : 's'}`;
+        }
+        const errSuffix = r.error ? ` (error: ${r.error})` : '';
+        console.log(`    [${r.name}] stats: ${statsLabel}; skills: ${skillsLabel}${errSuffix}`);
+    }
+    if (result.newlyReportedAgents.length > 0) {
+        console.log(`\n  First-time detections: ${result.newlyReportedAgents.join(', ')}`);
+    }
+    if (result.healthReported) {
+        console.log('  Health report: due (daily)');
+    }
+    console.log(`\n  Events to send (${result.events.length}):`);
+    const json = JSON.stringify(result.events, null, 2);
+    console.log(json
+        .split('\n')
+        .map(l => '    ' + l)
+        .join('\n'));
+}
+export function summarizeTelemetryForDryRun(result) {
+    const activeCount = result.adapterResults.filter(r => r.stats && r.stats !== 'unsupported' && r.stats.hasNewActivity).length;
+    const plural = (n, word) => `${n} ${word}${n === 1 ? '' : 's'}`;
+    return `Telemetry preview: ${plural(result.events.length, 'event')} would be sent (${plural(activeCount, 'adapter')} with activity). Use --verbose for details.`;
+}

package/dist/commands/sync.d.ts

@@ -5,6 +5,7 @@ export interface SyncOptions {
     pullOnly: boolean;
     prefer?: 'local' | 'remote';
     yes: boolean;
+    verbose?: boolean;
 }
 export declare function syncFromState(state: SetupState, statePath: string, credentials: Credentials, opts: SyncOptions): Promise<void>;
 export declare const syncCommand: Command;