@capgo/cli 8.0.0-alpha.5 → 8.0.0

package/dist/src/ai/stream-markdown.d.ts

@@ -0,0 +1,22 @@
+export interface StreamingMarkdownRenderer {
+    /** Feed a decoded text chunk (any split point — mid-line, mid-fence). */
+    feed: (text: string) => void;
+    /** Render the final line (the text after the last newline, possibly empty). */
+    flush: () => void;
+}
+/**
+ * Incremental wrapper over the line-based markdown renderer, for progressive
+ * TTY display of streamed AI analysis chunks.
+ *
+ * Buffers input until a newline completes a line, renders the completed line
+ * through `renderMarkdownLine` (threading the code-fence state), and emits it.
+ * Because every line is rendered by the exact same function the buffered
+ * `renderMarkdown` uses, the concatenated streamed output is byte-identical
+ * to `renderMarkdown(fullText)` — regardless of how the text was chunked.
+ * (test-ai-stream-markdown.mjs proves this for every possible split point.)
+ *
+ * Trade-off: nothing prints until a line completes, so streaming is
+ * line-by-line rather than character-by-character. Rewriting a partial line
+ * in place would break as soon as the line wraps past the terminal width.
+ */
+export declare function createStreamingMarkdownRenderer(write: (text: string) => void, isTTY: boolean): StreamingMarkdownRenderer;

package/dist/src/ai/telemetry.d.ts

@@ -0,0 +1,39 @@
+import type { PostAnalyzeResult } from './analyze.js';
+export type AiAnalysisChoice = 'capgo_ai' | 'local_ai' | 'skip' | 'auto_upload' | 'retry';
+export type AiAnalysisTriggeredBy = 'menu' | 'ci_flag' | 'onboarding';
+export type AiAnalysisResult = 'success' | 'already_analyzed' | 'too_big' | 'error' | 'mid_stream_error' | 'upgrade_required';
+export declare function aiAnalysisResultFromPostAnalyze(result: PostAnalyzeResult): AiAnalysisResult;
+export interface TrackAiAnalysisChoiceInput {
+    apikey: string;
+    orgId: string;
+    appId: string;
+    platform: 'ios' | 'android';
+    jobId: string;
+    choice: AiAnalysisChoice;
+    triggeredBy: AiAnalysisTriggeredBy;
+}
+export interface TrackAiAnalysisResultInput {
+    apikey: string;
+    orgId: string;
+    appId: string;
+    platform: 'ios' | 'android';
+    jobId: string;
+    result: AiAnalysisResult;
+    errorStatus?: number;
+}
+/**
+ * Emit `CLI AI Build Analysis Choice` for every branch the user (or CI flag) selected.
+ *
+ * Privacy boundary: only closed-enum choice + triggered_by metadata is sent. The
+ * AI diagnosis text is never observed at this stage.
+ */
+export declare function trackAiAnalysisChoice(input: TrackAiAnalysisChoiceInput): Promise<void>;
+/**
+ * Emit `CLI AI Build Analysis Result` only for paths that actually hit the server
+ * (capgo_ai or auto_upload).
+ *
+ * Privacy boundary: the AI analysis text (`result.analysis` in PostAnalyzeResult)
+ * MUST NEVER appear in any tag here. Only the closed-enum `result` and optional
+ * `error_status` cross the boundary.
+ */
+export declare function trackAiAnalysisResult(input: TrackAiAnalysisResultInput): Promise<void>;

package/dist/src/analytics/error-category.d.ts

@@ -0,0 +1,11 @@
+export type CliErrorCategory = 'network_error' | 'timeout' | 'unauthorized' | 'forbidden' | 'not_found' | 'payload_too_large' | 'rate_limited' | 'validation_error' | 'server_error' | 'commander' | 'unknown';
+/**
+ * Maps an arbitrary thrown value to a closed enum so telemetry never leaks
+ * error text, paths, or user input. Returns 'unknown' for anything unmatched.
+ */
+export declare function categorizeCliError(error: unknown): CliErrorCategory;
+/**
+ * Maps a non-2xx HTTP status to the same closed enum, for Supabase responses
+ * where we have a status code but no thrown Error. Never leaks response bodies.
+ */
+export declare function categorizeHttpStatus(status: number): CliErrorCategory;

package/dist/src/analytics/org-resolver.d.ts

@@ -0,0 +1,11 @@
+import { createSupabaseClient } from '../utils';
+export interface OrgResolverDeps {
+    /** Injectable for tests; defaults to the real Supabase client factory. */
+    createClient?: typeof createSupabaseClient;
+}
+/**
+ * Resolves an app's owner organization id (`apps.owner_org`), promise-cached
+ * per `(apikey, appId)`. Returns undefined on any error — never throws.
+ * Extracted so the analytics layer and onboarding analytics share one path.
+ */
+export declare function resolveOwnerOrgId(apikey: string, appId: string, deps?: OrgResolverDeps, signal?: AbortSignal): Promise<string | undefined>;

package/dist/src/analytics/supabase-perf.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Tags every Supabase call made inside `fn` with `source`.
+ *
+ * The Supabase JS query builder is a lazy thenable: it does not call `fetch`
+ * until `.then()` is invoked (i.e. when the caller `await`s it). If we only
+ * call `run(source, fn)` and return the builder, `.then()` fires *outside* the
+ * AsyncLocalStorage context and `getSupabaseSource()` returns `undefined`.
+ *
+ * To fix this, we wrap the result in `Promise.resolve()` inside the `run()`
+ * callback. This schedules the microtask (which calls `.then()` on the builder)
+ * while still inside the async context, so the source label propagates through
+ * to the actual fetch. For plain Promises and non-thenable values the behaviour
+ * is unchanged.
+ */
+export declare function withSupabaseSource<T>(source: string, fn: () => T): Promise<Awaited<T>>;
+export declare function getSupabaseSource(): string | undefined;
+export declare function enableSupabaseInstrumentation(): void;
+export declare function isSupabaseInstrumentationEnabled(): boolean;
+export interface SupabaseCallInfo {
+    url: string;
+    method: string;
+    status: number;
+    ok: boolean;
+    durationMs: number;
+    source?: string;
+    apikey?: string;
+    error?: unknown;
+}
+export type SupabaseCallRecorder = (info: SupabaseCallInfo) => void;
+export declare function setSupabaseCallRecorder(fn: SupabaseCallRecorder): void;
+/** A Supabase call slower than this is flagged `slow` regardless of status. */
+export declare const SLOW_THRESHOLD_MS = 5000;
+/**
+ * Parses a Supabase REST/RPC/Functions URL into a low-cardinality operation label.
+ * Query strings are discarded so filter values never leak and cardinality
+ * stays bounded. `/rest/v1/rpc/get_user_id` => `rpc:get_user_id`;
+ * `/rest/v1/apps?...` => `GET apps`;
+ * `/functions/v1/files/upload_link` => `POST functions:files/upload_link`.
+ */
+export declare function deriveSupabaseOperation(url: string, method: string): string;
+/**
+ * A `fetch` wrapper for supabase-js's `global.fetch`. Times the real request
+ * (which runs regardless), captures the active source label, and hands the
+ * result to the injected recorder. Returns the real Response / rethrows the
+ * real error so supabase-js behavior is never altered. Calls `globalThis.fetch`
+ * dynamically (not a captured ref) so it is testable and never self-recurses.
+ */
+export declare function createTimedFetch(): typeof fetch;

package/dist/src/analytics/track.d.ts

@@ -0,0 +1,70 @@
+import { withSupabaseSource } from './supabase-perf';
+type InvocationSource = 'cli' | 'mcp';
+export declare function setInvocationSource(source: InvocationSource): void;
+export declare function getInvocationSource(): InvocationSource;
+export declare function isTelemetryDisabled(): boolean;
+export interface GlobalAnalyticsProps {
+    cli_version: string;
+    node_version: string;
+    os_platform: string;
+    os_arch: string;
+    is_ci: boolean;
+    is_tty: boolean;
+    invocation_source: InvocationSource;
+    ci_provider?: string;
+}
+export declare function getGlobalAnalyticsProps(): GlobalAnalyticsProps;
+export declare function flushAnalytics(timeoutMs?: number): Promise<void>;
+export declare function resolveTrackingContext(apikey: string, signal?: AbortSignal): Promise<{
+    appId?: string;
+    orgId?: string;
+}>;
+export interface TrackEventInput {
+    channel: string;
+    event: string;
+    icon?: string;
+    /** Org id for actor-scoped attribution. Omitted => resolved best-effort. */
+    orgId?: string;
+    /** App id (also lets the backend verify org ownership). */
+    appId?: string;
+    /** Explicit key; falls back to the saved key. No key => no event. */
+    apikey?: string;
+    tags?: Record<string, string | number | boolean>;
+}
+/**
+ * Generic v2 actor-scoped event. Never throws. Does nothing when telemetry is
+ * disabled or no API key is resolvable (the accepted unauthenticated gap).
+ * When the caller omits appId/orgId, both are resolved best-effort from the
+ * local Capacitor config (app_id → owner_org) so local commands still get
+ * user + org attribution when the user is logged in.
+ */
+export declare function trackEvent(input: TrackEventInput): Promise<void>;
+export interface CommandContext {
+    flags: string[];
+    positional_arg_count: number;
+}
+interface CommanderLike {
+    args: readonly string[];
+    opts: () => Record<string, unknown>;
+    getOptionValueSource: (key: string) => string | undefined;
+}
+/**
+ * Pulls only privacy-safe context from a Commander command: the NAMES of
+ * user-provided flags (never their values) and the positional arg count.
+ */
+export declare function extractCommandContext(command: CommanderLike): CommandContext;
+export declare function trackCommandInvoked(commandPath: string, ctx: CommandContext): void;
+export declare function trackCommandSucceeded(commandPath: string): void;
+export declare function trackCommandFailed(commandPath: string, opts: {
+    errorCategory: string;
+    exitCode: number;
+}): void;
+type AnyAsyncFn = (...args: any[]) => Promise<any>;
+/**
+ * Wraps an MCP tool handler to emit a `MCP Tool Invoked` event with the tool
+ * name, success flag, and duration. Re-throws so behavior is unchanged.
+ */
+export declare function withMcpToolTracking<H extends AnyAsyncFn>(toolName: string, handler: H): H;
+export declare function trackMcpServerStarted(hasApikey: boolean): void;
+export { withSupabaseSource };
+export { enableSupabaseInstrumentation } from './supabase-perf';

package/dist/src/api/app.d.ts

@@ -1,13 +1,22 @@
 import type { SupabaseClient } from '@supabase/supabase-js';
 import type { Database } from '../types/supabase.types';
-import type { OptionsBase } from '../utils';
 import { OrganizationPerm } from '../utils';
 export declare function checkAppExists(supabase: SupabaseClient<Database>, appid: string): Promise<boolean>;
-export declare function checkAppExistsAndHasPermissionOrgErr(supabase: SupabaseClient<Database>, apikey: string, appid: string, requiredPermission: OrganizationPerm, silent?: boolean): Promise<OrganizationPerm>;
-export interface Options extends OptionsBase {
-    name?: string;
-    icon?: string;
-    retention?: number;
-}
+export type PendingOnboardingApp = Pick<Database['public']['Tables']['apps']['Row'], 'app_id' | 'name' | 'icon_url' | 'need_onboarding' | 'existing_app' | 'ios_store_url' | 'android_store_url'>;
+export type ExistingOrganizationApp = Pick<Database['public']['Tables']['apps']['Row'], 'app_id' | 'name' | 'owner_org' | 'need_onboarding'>;
+export declare function listPendingOnboardingApps(supabase: SupabaseClient<Database>, orgId: string): Promise<PendingOnboardingApp[]>;
+export declare function findAppInOrganization(supabase: SupabaseClient<Database>, orgId: string, appId: string): Promise<ExistingOrganizationApp | null>;
+export declare function completePendingOnboardingApp(supabase: SupabaseClient<Database>, orgId: string, appId: string): Promise<void>;
+/**
+ * Check multiple app IDs at once for batch validation (e.g., for suggestions)
+ */
+export declare function checkAppIdsExist(supabase: SupabaseClient<Database>, appids: string[]): Promise<{
+    appid: string;
+    exists: boolean;
+}[]>;
+export declare function check2FAComplianceForApp(supabase: SupabaseClient<Database>, appid: string, silent?: boolean): Promise<void>;
+export declare function checkAppExistsAndHasPermissionOrgErr(supabase: SupabaseClient<Database>, apikey: string, appid: string, requiredPermission: OrganizationPerm, silent?: boolean, skip2FACheck?: boolean): Promise<OrganizationPerm>;
+export type { AppOptions as Options } from '../schemas/app';
 export declare const newIconPath = "assets/icon.png";
-//# sourceMappingURL=app.d.ts.map
+export declare const defaultAppIconPath = "public/capgo.png";
+export declare function getAppIconStoragePath(organizationUid: string, appId: string): string;