ae-tracking 0.1.0

package/dist/src/plan/draft.js

@@ -0,0 +1,104 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { getAutotrackEvents } from './autotrack.js';
+export function emptyDraft(meta) {
+    return {
+        meta: {
+            app_type: meta.app_type,
+            sdk_integration_mode: meta.sdk_integration_mode,
+            client_platforms: meta.client_platforms,
+            client_sdk_type: meta.client_sdk_type,
+            client_languages: meta.client_languages,
+            client_platform_languages: meta.client_platform_languages,
+            server_language: meta.server_language,
+            project_id: meta.project_id,
+            plan_name: meta.plan_name,
+            scenario: meta.scenario,
+            user_identity: meta.user_identity,
+        },
+        events: [],
+        event_properties: [],
+        common_event_properties: [],
+        user_properties: [],
+    };
+}
+// 兼容旧接口
+export function emptyDraftLegacy(appType, planName, sdkType) {
+    return emptyDraft({
+        app_type: appType,
+        sdk_integration_mode: 'client_only',
+        client_sdk_type: sdkType,
+        plan_name: planName,
+    });
+}
+export function loadDraft(p) {
+    return JSON.parse(fs.readFileSync(p, 'utf8'));
+}
+export function saveDraft(d, p) {
+    fs.mkdirSync(path.dirname(p), { recursive: true });
+    fs.writeFileSync(p, JSON.stringify(d, null, 2));
+}
+/**
+ * 向 draft 注入 SDK 自动采集事件
+ * 自动采集事件放在 events 数组末尾，标记 source: "autotrack", platform: "client"
+ */
+export function injectAutotrackEvents(draft) {
+    const mode = draft.meta.sdk_integration_mode;
+    // 仅 client_only 或 both 模式才注入自动采集事件
+    if (mode === 'server_only') {
+        return draft; // 服务端 SDK 无自动采集事件
+    }
+    // 兼容：优先使用 client_sdk_type，fallback 到旧字段 sdk_type
+    const sdkType = draft.meta.client_sdk_type || draft.meta.sdk_type;
+    if (!sdkType) {
+        return draft; // 未指定客户端 SDK 类型，不注入
+    }
+    // 支持数组类型（多平台场景）：合并去重
+    let autotrackEvents = [];
+    if (Array.isArray(sdkType)) {
+        const allEvents = sdkType.map(t => getAutotrackEvents(t)).flat();
+        // 去重（Android 和 iOS 的自动采集事件相同）
+        const seen = new Set();
+        autotrackEvents = allEvents.filter(e => {
+            if (seen.has(e.event_name))
+                return false;
+            seen.add(e.event_name);
+            return true;
+        });
+    }
+    else {
+        autotrackEvents = getAutotrackEvents(sdkType);
+    }
+    // 过滤掉已存在的自动采集事件（避免重复注入）
+    const existingAutotrackNames = new Set(draft.events.filter(e => e.source === 'autotrack').map(e => e.event_name));
+    const newEvents = autotrackEvents.filter(e => !existingAutotrackNames.has(e.event_name));
+    // 将自动采集事件追加到末尾，并设置 platform: "client"
+    const eventsWithPlatform = newEvents.map(e => ({
+        ...e,
+        platform: 'client',
+    }));
+    draft.events.push(...eventsWithPlatform);
+    return draft;
+}
+/**
+ * 获取 draft 中的业务事件（排除自动采集事件）
+ */
+export function getBusinessEvents(draft) {
+    return draft.events.filter(e => e.source !== 'autotrack');
+}
+/**
+ * 获取 draft 中的自动采集事件
+ */
+export function getAutotrackEventsFromDraft(draft) {
+    return draft.events.filter(e => e.source === 'autotrack');
+}
+/**
+ * 按 platform 分组获取事件
+ */
+export function getEventsByPlatform(draft) {
+    return {
+        client: draft.events.filter(e => e.platform === 'client'),
+        server: draft.events.filter(e => e.platform === 'server'),
+        both: draft.events.filter(e => e.platform === 'both'),
+    };
+}

package/dist/src/plan/fix.d.ts

@@ -0,0 +1,32 @@
+import type { Draft } from './types.js';
+/**
+ * 埋点方案自动修复
+ * 根据 AE API 返回的错误自动修复 draft.json
+ */
+export interface TEUploadError {
+    errorType: string;
+    errorTypeDesc: string;
+    cellName: string;
+    row: number;
+    value: string;
+}
+export interface TEUploadResponse {
+    return_code: number;
+    return_message: string;
+    data?: {
+        eventErrorMap?: Record<string, TEUploadError[]>;
+        userErrorMap?: Record<string, TEUploadError[]>;
+    };
+}
+/**
+ * 从 AE API 响应中提取错误
+ */
+export declare function extractErrors(response: TEUploadResponse): TEUploadError[];
+/**
+ * 自动修复 draft.json
+ */
+export declare function fixDraft(draft: Draft, response: TEUploadResponse): string[];
+/**
+ * 内部校验修复（在生成 xlsx 前执行）
+ */
+export declare function validateAndFix(draft: Draft): string[];

package/dist/src/plan/fix.js

@@ -0,0 +1,187 @@
+/**
+ * 从 AE API 响应中提取错误
+ */
+export function extractErrors(response) {
+    const errors = [];
+    if (response.data?.eventErrorMap) {
+        for (const [errorType, items] of Object.entries(response.data.eventErrorMap)) {
+            for (const item of items) {
+                errors.push({ ...item, errorType });
+            }
+        }
+    }
+    if (response.data?.userErrorMap) {
+        for (const [errorType, items] of Object.entries(response.data.userErrorMap)) {
+            for (const item of items) {
+                errors.push({ ...item, errorType });
+            }
+        }
+    }
+    return errors;
+}
+/**
+ * 修复显示名重复错误
+ */
+function fixDisplayDuplicate(draft, errors) {
+    // 收集重复的显示名
+    const duplicateDisplayNames = new Map();
+    for (const error of errors) {
+        if (error.errorType === 'event_prop_display_duplicate') {
+            const names = duplicateDisplayNames.get(error.value) || [];
+            names.push(error.value);
+            duplicateDisplayNames.set(error.value, names);
+        }
+    }
+    // 修复：给重复的显示名添加区分前缀
+    for (const prop of draft.event_properties) {
+        if (duplicateDisplayNames.has(prop.display_name || '')) {
+            // 找到这个属性在哪些事件中被引用
+            const eventsUsingProp = draft.events.filter(e => e.prop_names.includes(prop.name));
+            // 根据属性类型添加前缀
+            if (prop.name.includes('.')) {
+                // 子属性：添加"明细"前缀
+                prop.display_name = `明细${prop.display_name}`;
+            }
+            else if (eventsUsingProp.length > 0) {
+                // 根据事件类型添加前缀
+                prop.display_name = `${prop.display_name}（详情）`;
+            }
+        }
+    }
+}
+/**
+ * 修复对象组子属性不一致
+ */
+function fixArrayRowConsistency(draft, errors) {
+    // 收集每个 array_row 的完整子属性
+    const arrayRowChildren = new Map();
+    for (const prop of draft.event_properties) {
+        if (prop.type === 'array_row') {
+            arrayRowChildren.set(prop.name, []);
+        }
+    }
+    for (const prop of draft.event_properties) {
+        if (prop.name.includes('.')) {
+            const parent = prop.name.split('.')[0];
+            const children = arrayRowChildren.get(parent);
+            if (children) {
+                children.push(prop.name);
+            }
+        }
+    }
+    // 对每个事件，确保引用的 array_row 包含完整子属性
+    for (const event of draft.events) {
+        const propNamesSet = new Set(event.prop_names);
+        for (const [arrayRow, children] of arrayRowChildren) {
+            if (propNamesSet.has(arrayRow)) {
+                // 检查是否包含所有子属性
+                for (const child of children) {
+                    if (!propNamesSet.has(child)) {
+                        // 添加缺失的子属性
+                        event.prop_names.push(child);
+                    }
+                }
+                // 重新排序：先父属性，再子属性（按顺序）
+                const arrayRowProps = event.prop_names.filter(p => p === arrayRow || p.startsWith(arrayRow + '.'));
+                // 排序：父属性在前，子属性按 children 顺序
+                const sorted = [arrayRow, ...children.filter(c => event.prop_names.includes(c))];
+                // 移除旧的 array_row 相关属性，插入排序后的
+                event.prop_names = event.prop_names.filter(p => !p.startsWith(arrayRow) || p === arrayRow);
+                // 在 arrayRow 位置插入排序后的属性
+                const idx = event.prop_names.indexOf(arrayRow);
+                if (idx >= 0) {
+                    event.prop_names.splice(idx, 1, ...sorted);
+                }
+            }
+        }
+    }
+}
+/**
+ * 修复事件名重复
+ */
+function fixEventNameDuplicate(draft, errors) {
+    const duplicateEvents = new Set();
+    for (const error of errors) {
+        if (error.errorType === 'event_name_duplicate') {
+            duplicateEvents.add(error.value);
+        }
+    }
+    // 移除重复的事件（保留第一个）
+    const seen = new Set();
+    draft.events = draft.events.filter(event => {
+        if (duplicateEvents.has(event.event_name)) {
+            if (seen.has(event.event_name)) {
+                return false; // 移除后续重复
+            }
+            seen.add(event.event_name);
+        }
+        return true;
+    });
+}
+/**
+ * 自动修复 draft.json
+ */
+export function fixDraft(draft, response) {
+    const errors = extractErrors(response);
+    const fixed = [];
+    if (errors.length === 0) {
+        return fixed;
+    }
+    // 按错误类型分类
+    const errorTypes = new Set(errors.map(e => e.errorType));
+    // 修复显示名重复
+    if (errorTypes.has('event_prop_display_duplicate')) {
+        fixDisplayDuplicate(draft, errors);
+        fixed.push('修复显示名重复');
+    }
+    // 修复对象组子属性不一致
+    if (errorTypes.has('complex_event_property_should_has_same_child_property')) {
+        fixArrayRowConsistency(draft, errors);
+        fixed.push('修复对象组子属性不一致');
+    }
+    // 修复事件名重复
+    if (errorTypes.has('event_name_duplicate')) {
+        fixEventNameDuplicate(draft, errors);
+        fixed.push('移除重复事件');
+    }
+    return fixed;
+}
+/**
+ * 内部校验修复（在生成 xlsx 前执行）
+ */
+export function validateAndFix(draft) {
+    const fixed = [];
+    // 修复对象组子属性不一致
+    const arrayRowChildren = new Map();
+    for (const prop of draft.event_properties) {
+        if (prop.type === 'array_row') {
+            arrayRowChildren.set(prop.name, []);
+        }
+    }
+    for (const prop of draft.event_properties) {
+        if (prop.name.includes('.')) {
+            const parent = prop.name.split('.')[0];
+            const children = arrayRowChildren.get(parent);
+            if (children) {
+                children.push(prop.name);
+            }
+        }
+    }
+    let needFix = false;
+    for (const event of draft.events) {
+        for (const [arrayRow, children] of arrayRowChildren) {
+            if (event.prop_names.includes(arrayRow)) {
+                for (const child of children) {
+                    if (!event.prop_names.includes(child)) {
+                        needFix = true;
+                    }
+                }
+            }
+        }
+    }
+    if (needFix) {
+        fixArrayRowConsistency(draft, []);
+        fixed.push('修复对象组子属性不一致');
+    }
+    return fixed;
+}

package/dist/src/plan/types.d.ts

@@ -0,0 +1,57 @@
+export type PropType = 'string' | 'number' | 'bool' | 'datetime' | 'array_row' | 'array_string';
+export type UpdateType = 'user_set' | 'user_setOnce' | 'user_add';
+export type Source = 'template' | 'prd' | 'chat' | 'autotrack';
+export type SDKIntegrationMode = 'client_only' | 'server_only' | 'both';
+export type EventPlatform = 'client' | 'server' | 'both';
+export type ServerLanguage = 'java' | 'python' | 'go' | 'nodejs' | 'php' | 'csharp' | 'cpp' | 'ruby' | 'lua' | 'other';
+export type ClientLanguage = 'java' | 'kotlin' | 'objc' | 'swift' | 'javascript' | 'typescript' | 'csharp' | 'cpp' | 'lua' | 'dart' | 'vue' | 'other';
+export type SDKType = 'android' | 'ios' | 'openharmony' | 'javascript' | 'wechat_mp' | 'wechat_mg' | 'douyin_mp' | 'alipay_mp' | 'other_mp' | 'unity' | 'unity_wxmg' | 'cocos2dx' | 'cocoscreator' | 'layaair' | 'unreal' | 'react_native' | 'flutter' | 'uniapp_mp' | 'uniapp_app' | 'uniapp_h5';
+export interface Property {
+    name: string;
+    display_name?: string;
+    type: PropType;
+    desc?: string;
+    source: Source;
+}
+export interface UserProperty extends Property {
+    update_type?: UpdateType;
+    prop_tag?: string;
+}
+export interface Event {
+    event_name: string;
+    display_name?: string;
+    event_tag?: string;
+    event_desc?: string;
+    platform?: EventPlatform;
+    source: Source;
+    prop_names: string[];
+}
+export type AccountIdSource = 'user_account' | 'role_id' | 'none';
+export type DistinctIdStrategy = 'auto' | 'device_id' | 'custom';
+export interface UserIdentity {
+    account_id_source: AccountIdSource;
+    account_id_field?: string;
+    distinct_id_strategy: DistinctIdStrategy;
+    distinct_id_custom_value?: string;
+}
+export interface Draft {
+    meta: {
+        app_type: string;
+        sdk_integration_mode: SDKIntegrationMode;
+        client_platforms?: SDKType[];
+        client_sdk_type?: SDKType;
+        client_languages?: ClientLanguage[];
+        client_platform_languages?: Record<SDKType, ClientLanguage[]>;
+        server_language?: ServerLanguage;
+        project_id?: number;
+        host?: string;
+        plan_name: string;
+        scenario?: string;
+        user_identity?: UserIdentity;
+        sdk_type?: SDKType;
+    };
+    events: Event[];
+    event_properties: Property[];
+    common_event_properties: Property[];
+    user_properties: UserProperty[];
+}

package/dist/src/plan/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/project-detect/detect.d.ts

@@ -0,0 +1,2 @@
+import type { DetectResult } from './types.js';
+export declare function detectProject(cwd: string): Promise<DetectResult>;

package/dist/src/project-detect/detect.js

@@ -0,0 +1,120 @@
+import { readFile, readdir, stat } from 'node:fs/promises';
+import { join } from 'node:path';
+async function exists(p) {
+    try {
+        await stat(p);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function readJson(p) {
+    try {
+        return JSON.parse(await readFile(p, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+/** Classify a single directory (no recursive walk). Returns 'unknown' if unrecognised. */
+async function classifyDir(cwd) {
+    if (await exists(join(cwd, 'project.config.json'))) {
+        const cfg = await readJson(join(cwd, 'project.config.json'));
+        if (cfg && 'miniprogramRoot' in cfg)
+            return 'mini-program';
+    }
+    if (await exists(join(cwd, 'ProjectSettings/ProjectVersion.txt')))
+        return 'unity';
+    if (await exists(join(cwd, 'Podfile')))
+        return 'ios';
+    if (await exists(join(cwd, 'build.gradle')) || await exists(join(cwd, 'settings.gradle')))
+        return 'android';
+    const pkg = await readJson(join(cwd, 'package.json'));
+    if (pkg) {
+        const deps = { ...(pkg.dependencies ?? {}), ...(pkg.devDependencies ?? {}) };
+        if (deps.astro)
+            return 'web-astro';
+        if (deps.next)
+            return 'web-nextjs';
+        if (deps.react)
+            return 'web-react';
+        if (deps.vue)
+            return 'web-vue';
+        if (deps.express || deps.fastify || deps.koa)
+            return 'node-server';
+        return 'web-vanilla';
+    }
+    if (await exists(join(cwd, 'go.mod')))
+        return 'go-server';
+    if (await exists(join(cwd, 'pom.xml')))
+        return 'java-server';
+    if (await exists(join(cwd, 'pyproject.toml')) || await exists(join(cwd, 'requirements.txt')))
+        return 'python-server';
+    return 'unknown';
+}
+/** Classify cwd, walking 1 level into subdirs if cwd itself is unrecognised (monorepo support). */
+async function classify(cwd) {
+    // 1. Try cwd directly
+    const direct = await classifyDir(cwd);
+    if (direct !== 'unknown')
+        return { appType: direct, subPath: undefined };
+    // 2. Walk direct children (max 20 to avoid huge monorepos)
+    let entries;
+    try {
+        entries = await readdir(cwd, { withFileTypes: true });
+    }
+    catch {
+        return { appType: 'unknown', subPath: undefined };
+    }
+    const dirs = entries
+        .filter(e => e.isDirectory() && !e.name.startsWith('.') && e.name !== 'node_modules')
+        .slice(0, 20);
+    // During monorepo walk, prefer specific types over 'web-vanilla' (which is a
+    // catch-all for any package.json with no recognised framework).
+    let vanillaMatch;
+    for (const d of dirs) {
+        const sub = await classifyDir(join(cwd, d.name));
+        if (sub !== 'unknown' && sub !== 'web-vanilla') {
+            return { appType: sub, subPath: d.name };
+        }
+        if (sub === 'web-vanilla' && !vanillaMatch) {
+            vanillaMatch = { appType: sub, subPath: d.name };
+        }
+    }
+    if (vanillaMatch)
+        return vanillaMatch;
+    return { appType: 'unknown', subPath: undefined };
+}
+function recommend(appType) {
+    switch (appType) {
+        case 'web-react':
+        case 'web-vue':
+        case 'web-nextjs':
+        case 'web-vanilla':
+        case 'web-astro':
+        case 'ios':
+        case 'android':
+        case 'mini-program':
+        case 'unity':
+            return ['A', 'F'];
+        case 'node-server':
+        case 'python-server':
+        case 'go-server':
+        case 'java-server':
+            return ['E', 'F'];
+        case 'unknown':
+        default:
+            return ['B', 'E'];
+    }
+}
+export async function detectProject(cwd) {
+    const { appType, subPath } = await classify(cwd);
+    return {
+        appType,
+        subPath,
+        entryFiles: [],
+        existingTracking: [],
+        recommendedModes: recommend(appType),
+    };
+}

package/dist/src/project-detect/types.d.ts

@@ -0,0 +1,9 @@
+export type AppType = 'web-react' | 'web-vue' | 'web-nextjs' | 'web-vanilla' | 'web-astro' | 'ios' | 'android' | 'mini-program' | 'unity' | 'node-server' | 'python-server' | 'go-server' | 'java-server' | 'unknown';
+export type Mode = 'A' | 'B' | 'C' | 'D' | 'E' | 'F';
+export interface DetectResult {
+    appType: AppType;
+    subPath?: string;
+    entryFiles: string[];
+    existingTracking: string[];
+    recommendedModes: Mode[];
+}

package/dist/src/project-detect/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/te-debug/client.d.ts

@@ -0,0 +1,12 @@
+import type { DebugClientOpts, DeviceInfo, DeviceDataResponse } from './types.js';
+export declare class TEDebugClient {
+    private opts;
+    constructor(opts: DebugClientOpts);
+    private url;
+    private get;
+    listDevice(projectId: number): Promise<DeviceInfo[]>;
+    addDevice(projectId: number, deviceId: string, deviceName: string): Promise<void>;
+    selectDevice(projectId: number, deviceId: string): Promise<void>;
+    removeDevice(projectId: number, deviceId: string): Promise<void>;
+    listDeviceData(projectId: number, deviceId: string, startTime: string): Promise<DeviceDataResponse>;
+}

package/dist/src/te-debug/client.js

@@ -0,0 +1,54 @@
+import { request } from 'undici';
+const BASE = '/v1/ta/bury/manage/debug';
+export class TEDebugClient {
+    opts;
+    constructor(opts) {
+        this.opts = opts;
+    }
+    url(path, params) {
+        const parts = [`@t=${Date.now()}`];
+        for (const [k, v] of Object.entries(params)) {
+            parts.push(`${encodeURIComponent(k)}=${encodeURIComponent(String(v))}`);
+        }
+        return this.opts.host.replace(/\/$/, '') + BASE + path + '?' + parts.join('&');
+    }
+    async get(path, params) {
+        const r = await request(this.url(path, params), {
+            method: 'GET',
+            headers: {
+                authorization: `bearer ${this.opts.token}`,
+                'x-requested-with': 'XMLHttpRequest',
+                accept: 'application/json',
+            },
+        });
+        const env = (await r.body.json());
+        if (env.return_code !== 0) {
+            if (env.return_code === -1001) {
+                throw new Error(`AE token expired or invalid (return_code -1001). Re-login in Chrome, then run: ae-tracking auth login`);
+            }
+            throw new Error(env.return_message || `AE error ${env.return_code}`);
+        }
+        return env.data;
+    }
+    async listDevice(projectId) {
+        const data = await this.get('/listDevice', { projectId });
+        return data?.deviceList ?? [];
+    }
+    async addDevice(projectId, deviceId, deviceName) {
+        await this.get('/saveDevice', { deviceId, deviceName, projectId });
+    }
+    async selectDevice(projectId, deviceId) {
+        await this.get('/chooseDevice', { deviceId, projectId });
+    }
+    async removeDevice(projectId, deviceId) {
+        await this.get('/deleteDevice', { deviceId, projectId });
+    }
+    async listDeviceData(projectId, deviceId, startTime) {
+        const data = await this.get('/listDeviceData', {
+            deviceID: deviceId, // NB uppercase D — matches AE backend
+            projectId,
+            startTime,
+        });
+        return data ?? { eventList: [], deviceDataList: [] };
+    }
+}

package/dist/src/te-debug/types.d.ts

@@ -0,0 +1,16 @@
+export interface DebugClientOpts {
+    host: string;
+    token: string;
+}
+export interface DeviceInfo {
+    deviceId: string;
+    deviceName: string;
+    lastClearTime?: string;
+}
+export interface DeviceDataItem {
+    [key: string]: unknown;
+}
+export interface DeviceDataResponse {
+    eventList: DeviceDataItem[];
+    deviceDataList: DeviceDataItem[];
+}

package/dist/src/te-debug/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/te-plan/fetch.d.ts

@@ -0,0 +1,3 @@
+import type { Draft } from '../plan/types.js';
+import type { FetchPlanArgs } from './types.js';
+export declare function fetchPlan({ projectId, host, token }: FetchPlanArgs): Promise<Draft>;

package/dist/src/te-plan/fetch.js

@@ -0,0 +1,47 @@
+import { request } from 'undici';
+const PLAN_PATH = '/v1/ta/bury/manage/program/query';
+export async function fetchPlan({ projectId, host, token }) {
+    const url = `${host.replace(/\/$/, '')}${PLAN_PATH}?@t=${Date.now()}&projectId=${projectId}`;
+    const { statusCode, body } = await request(url, {
+        method: 'GET',
+        headers: {
+            authorization: `bearer ${token}`,
+            'x-requested-with': 'XMLHttpRequest',
+        },
+    });
+    if (statusCode !== 200) {
+        const text = await body.text();
+        throw new Error(`AE plan fetch failed (${statusCode}): ${text.slice(0, 200)}`);
+    }
+    const payload = (await body.json());
+    if (payload.return_code !== 0) {
+        if (payload.return_code === -1001) {
+            throw new Error(`AE token expired or invalid (return_code -1001). Re-login in Chrome, then run: ae-tracking auth login`);
+        }
+        throw new Error(`AE plan fetch return_code ${payload.return_code}: ${payload.return_message ?? ''}`);
+    }
+    return normalize(payload.data);
+}
+function normalize(data) {
+    return {
+        meta: { app_type: 'unknown', sdk_integration_mode: 'client_only', plan_name: 'from-te' },
+        events: (data.events ?? []).map((e) => ({
+            event_name: e.eventName,
+            display_name: e.displayName,
+            event_tag: e.eventTag,
+            event_desc: e.eventDesc,
+            source: 'chat',
+            prop_names: e.props ?? [],
+        })),
+        event_properties: (data.eventProps ?? []).map((p) => ({
+            name: p.name, display_name: p.displayName, type: (p.type?.toLowerCase() ?? 'string'), desc: p.desc, source: 'chat',
+        })),
+        common_event_properties: (data.commonEventProps ?? []).map((p) => ({
+            name: p.name, display_name: p.displayName, type: (p.type?.toLowerCase() ?? 'string'), desc: p.desc, source: 'chat',
+        })),
+        user_properties: (data.userProps ?? []).map((p) => ({
+            name: p.name, display_name: p.displayName, type: (p.type?.toLowerCase() ?? 'string'), desc: p.desc,
+            update_type: (p.updateType ?? 'user_set'), prop_tag: p.propTag, source: 'chat',
+        })),
+    };
+}

package/dist/src/te-plan/types.d.ts

@@ -0,0 +1,7 @@
+import type { Draft } from '../plan/types.js';
+export interface FetchPlanArgs {
+    projectId: number;
+    host: string;
+    token: string;
+}
+export type { Draft };

package/dist/src/te-plan/types.js

@@ -0,0 +1 @@
+export {};