@jackwener/opencli 1.5.5 → 1.5.7

package/dist/clis/zsxq/topic.test.js

@@ -0,0 +1,29 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { getRegistry } from '../../registry.js';
+import './topic.js';
+describe('zsxq topic command', () => {
+    beforeEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('maps topic detail 404 responses to NOT_FOUND before fetching comments', async () => {
+        const command = getRegistry().get('zsxq/topic');
+        expect(command?.func).toBeTypeOf('function');
+        const mockPage = {
+            goto: vi.fn().mockResolvedValue(undefined),
+            evaluate: vi.fn()
+                .mockResolvedValueOnce(true)
+                .mockResolvedValueOnce({
+                ok: true,
+                status: 404,
+                url: 'https://api.zsxq.com/v2/topics/404',
+                data: null,
+            }),
+        };
+        await expect(command.func(mockPage, { id: '404', comment_limit: 20 })).rejects.toMatchObject({
+            code: 'NOT_FOUND',
+            message: 'Topic 404 not found',
+        });
+        expect(mockPage.goto).toHaveBeenCalledWith('https://wx.zsxq.com');
+        expect(mockPage.evaluate).toHaveBeenCalledTimes(2);
+    });
+});

package/dist/clis/zsxq/topics.d.ts

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

package/dist/clis/zsxq/topics.js

@@ -0,0 +1,25 @@
+import { cli, Strategy } from '../../registry.js';
+import { getActiveGroupId, ensureZsxqAuth, ensureZsxqPage, fetchFirstJson, getTopicsFromResponse, toTopicRow, } from './utils.js';
+cli({
+    site: 'zsxq',
+    name: 'topics',
+    description: '获取当前星球的话题列表',
+    domain: 'wx.zsxq.com',
+    strategy: Strategy.COOKIE,
+    browser: true,
+    args: [
+        { name: 'limit', type: 'int', default: 20, help: 'Number of topics to return' },
+        { name: 'group_id', help: 'Optional group id; defaults to the active group in Chrome' },
+    ],
+    columns: ['topic_id', 'type', 'author', 'title', 'comments', 'likes', 'time', 'url'],
+    func: async (page, kwargs) => {
+        await ensureZsxqPage(page);
+        await ensureZsxqAuth(page);
+        const limit = Math.max(1, Number(kwargs.limit) || 20);
+        const groupId = String(kwargs.group_id || await getActiveGroupId(page));
+        const { data } = await fetchFirstJson(page, [
+            `https://api.zsxq.com/v2/groups/${groupId}/topics?scope=all&count=${limit}`,
+        ]);
+        return getTopicsFromResponse(data).slice(0, limit).map(toTopicRow);
+    },
+});

package/dist/clis/zsxq/topics.test.d.ts

@@ -0,0 +1 @@
+import './topics.js';

package/dist/clis/zsxq/topics.test.js

@@ -0,0 +1,24 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { getRegistry } from '../../registry.js';
+import './topics.js';
+describe('zsxq topics command', () => {
+    beforeEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('requires an explicit group_id when there is no active group context', async () => {
+        const command = getRegistry().get('zsxq/topics');
+        expect(command?.func).toBeTypeOf('function');
+        const mockPage = {
+            goto: vi.fn().mockResolvedValue(undefined),
+            evaluate: vi.fn()
+                .mockResolvedValueOnce(true)
+                .mockResolvedValueOnce(null),
+        };
+        await expect(command.func(mockPage, { limit: 20 })).rejects.toMatchObject({
+            code: 'ARGUMENT',
+            message: 'Cannot determine active group_id',
+        });
+        expect(mockPage.goto).toHaveBeenCalledWith('https://wx.zsxq.com');
+        expect(mockPage.evaluate).toHaveBeenCalledTimes(2);
+    });
+});

package/dist/clis/zsxq/utils.d.ts

@@ -0,0 +1,97 @@
+import type { IPage } from '../../types.js';
+export interface ZsxqUser {
+    user_id?: number;
+    name?: string;
+    avatar_url?: string;
+}
+export interface ZsxqGroup {
+    group_id?: number;
+    name?: string;
+    description?: string;
+    background_url?: string;
+    owner?: ZsxqUser;
+    statistics?: {
+        topics_count?: number;
+        answers_count?: number;
+        comments_count?: number;
+        likes_count?: number;
+        subscriptions_count?: number;
+    };
+    category?: {
+        title?: string;
+    };
+    user_specific?: {
+        join_time?: string;
+        validity?: {
+            end_time?: string;
+        };
+    };
+}
+export interface ZsxqComment {
+    comment_id?: number;
+    create_time?: string;
+    text?: string;
+    owner?: ZsxqUser;
+    likes_count?: number;
+    rewards_count?: number;
+    repliee?: ZsxqUser;
+}
+export interface ZsxqTopic {
+    topic_id?: number;
+    create_time?: string;
+    comments_count?: number;
+    likes_count?: number;
+    readers_count?: number;
+    reading_count?: number;
+    rewards_count?: number;
+    title?: string;
+    type?: string;
+    group?: ZsxqGroup;
+    owner?: ZsxqUser;
+    user_specific?: Record<string, unknown>;
+    talk?: {
+        owner?: ZsxqUser;
+        text?: string;
+    };
+    question?: {
+        owner?: ZsxqUser;
+        text?: string;
+    };
+    answer?: {
+        owner?: ZsxqUser;
+        text?: string;
+    };
+    task?: {
+        owner?: ZsxqUser;
+        text?: string;
+    };
+    solution?: {
+        owner?: ZsxqUser;
+        text?: string;
+    };
+    show_comments?: ZsxqComment[];
+    comments?: ZsxqComment[];
+}
+export interface BrowserFetchResult {
+    ok: boolean;
+    url?: string;
+    status?: number;
+    error?: string;
+    data?: unknown;
+}
+export declare function ensureZsxqPage(page: IPage): Promise<void>;
+export declare function ensureZsxqAuth(page: IPage): Promise<void>;
+export declare function getCookieValue(page: IPage, name: string): Promise<string | undefined>;
+export declare function getActiveGroupId(page: IPage): Promise<string>;
+export declare function browserJsonRequest(page: IPage, path: string): Promise<BrowserFetchResult>;
+export declare function fetchFirstJson(page: IPage, paths: string[]): Promise<BrowserFetchResult>;
+export declare function unwrapRespData<T>(payload: unknown): T;
+export declare function getTopicsFromResponse(payload: unknown): ZsxqTopic[];
+export declare function getCommentsFromResponse(payload: unknown): ZsxqComment[];
+export declare function getGroupsFromResponse(payload: unknown): ZsxqGroup[];
+export declare function getTopicFromResponse(payload: unknown): ZsxqTopic | null;
+export declare function getTopicAuthor(topic: ZsxqTopic): string;
+export declare function getTopicText(topic: ZsxqTopic): string;
+export declare function getTopicUrl(topicId: number | string | undefined): string;
+export declare function summarizeComments(comments: ZsxqComment[], limit?: number): string;
+export declare function toTopicRow(topic: ZsxqTopic): Record<string, unknown>;

package/dist/clis/zsxq/utils.js

@@ -0,0 +1,230 @@
+import { ArgumentError, AuthRequiredError, CliError } from '../../errors.js';
+const SITE_DOMAIN = 'wx.zsxq.com';
+const SITE_URL = 'https://wx.zsxq.com';
+function asRecord(value) {
+    return value && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : null;
+}
+function pickArray(...values) {
+    for (const value of values) {
+        if (Array.isArray(value)) {
+            return value;
+        }
+    }
+    return [];
+}
+export async function ensureZsxqPage(page) {
+    await page.goto(SITE_URL);
+}
+export async function ensureZsxqAuth(page) {
+    // zsxq uses httpOnly cookies that may be on different subdomains.
+    // Verify auth by attempting a lightweight API call instead of checking cookies.
+    try {
+        const result = await page.evaluate(`
+      (async () => {
+        try {
+          const r = await new Promise((resolve, reject) => {
+            const xhr = new XMLHttpRequest();
+            xhr.open('GET', 'https://api.zsxq.com/v2/groups', true);
+            xhr.withCredentials = true;
+            xhr.setRequestHeader('accept', 'application/json');
+            xhr.onload = () => {
+              if (xhr.status >= 200 && xhr.status < 300) {
+                try { resolve(JSON.parse(xhr.responseText)); }
+                catch { resolve(null); }
+              } else { resolve(null); }
+            };
+            xhr.onerror = () => resolve(null);
+            xhr.send();
+          });
+          return r !== null;
+        } catch { return false; }
+      })()
+    `);
+        if (!result) {
+            throw new AuthRequiredError('zsxq.com');
+        }
+    }
+    catch (err) {
+        if (err instanceof AuthRequiredError)
+            throw err;
+        throw new AuthRequiredError('zsxq.com');
+    }
+}
+export async function getCookieValue(page, name) {
+    const cookies = await page.getCookies({ domain: SITE_DOMAIN });
+    return cookies.find(cookie => cookie.name === name)?.value;
+}
+export async function getActiveGroupId(page) {
+    const groupId = await page.evaluate(`
+    (() => {
+      const target = localStorage.getItem('target_group');
+      if (target) {
+        try {
+          const parsed = JSON.parse(target);
+          if (parsed.group_id) return String(parsed.group_id);
+        } catch {}
+      }
+      return null;
+    })()
+  `);
+    if (groupId)
+        return groupId;
+    throw new ArgumentError('Cannot determine active group_id', 'Pass --group_id <id> or open the target 知识星球 page in Chrome first');
+}
+export async function browserJsonRequest(page, path) {
+    return await page.evaluate(`
+    (async () => {
+      const path = ${JSON.stringify(path)};
+
+      try {
+        return await new Promise((resolve) => {
+          const xhr = new XMLHttpRequest();
+          xhr.open('GET', path, true);
+          xhr.withCredentials = true;
+          xhr.setRequestHeader('accept', 'application/json, text/plain, */*');
+          xhr.onload = () => {
+            let parsed = null;
+            if (xhr.responseText) {
+              try { parsed = JSON.parse(xhr.responseText); }
+              catch {}
+            }
+
+            resolve({
+              ok: xhr.status >= 200 && xhr.status < 300,
+              url: path,
+              status: xhr.status,
+              data: parsed,
+              error: xhr.status >= 200 && xhr.status < 300 ? undefined : 'HTTP ' + xhr.status,
+            });
+          };
+          xhr.onerror = () => resolve({
+            ok: false,
+            url: path,
+            error: 'Network error',
+          });
+          xhr.send();
+        });
+      } catch (error) {
+        return {
+          ok: false,
+          url: path,
+          error: error instanceof Error ? error.message : String(error),
+        };
+      }
+    })()
+  `);
+}
+export async function fetchFirstJson(page, paths) {
+    let lastFailure = null;
+    for (const path of paths) {
+        const result = await browserJsonRequest(page, path);
+        if (result.ok) {
+            return result;
+        }
+        lastFailure = result;
+    }
+    if (!lastFailure) {
+        throw new CliError('FETCH_ERROR', 'No candidate endpoint returned JSON', `Checked endpoints: ${paths.join(', ')}`);
+    }
+    throw new CliError('FETCH_ERROR', lastFailure.error || 'Failed to fetch ZSXQ API', `Checked endpoints: ${paths.join(', ')}`);
+}
+export function unwrapRespData(payload) {
+    const record = asRecord(payload);
+    if (!record) {
+        throw new CliError('PARSE_ERROR', 'Invalid ZSXQ API response');
+    }
+    if (record.succeeded === false) {
+        const code = typeof record.code === 'number' ? String(record.code) : 'API_ERROR';
+        const message = typeof record.info === 'string'
+            ? record.info
+            : typeof record.error === 'string'
+                ? record.error
+                : 'ZSXQ API returned an error';
+        throw new CliError(code, message);
+    }
+    return (record.resp_data ?? record.data ?? payload);
+}
+export function getTopicsFromResponse(payload) {
+    const data = unwrapRespData(payload);
+    if (Array.isArray(data))
+        return data;
+    return pickArray(data.topics, data.list, data.records, data.items, data.search_result);
+}
+export function getCommentsFromResponse(payload) {
+    const data = unwrapRespData(payload);
+    if (Array.isArray(data))
+        return data;
+    return pickArray(data.comments, data.list, data.items);
+}
+export function getGroupsFromResponse(payload) {
+    const data = unwrapRespData(payload);
+    if (Array.isArray(data))
+        return data;
+    return pickArray(data.groups, data.list, data.items);
+}
+export function getTopicFromResponse(payload) {
+    const data = unwrapRespData(payload);
+    if (Array.isArray(data))
+        return data[0] ?? null;
+    if (typeof data.topic_id === 'number')
+        return data;
+    const record = asRecord(data);
+    if (!record)
+        return null;
+    const topic = record.topic;
+    return topic && typeof topic === 'object' ? topic : null;
+}
+export function getTopicAuthor(topic) {
+    return (topic.owner?.name ||
+        topic.talk?.owner?.name ||
+        topic.question?.owner?.name ||
+        topic.answer?.owner?.name ||
+        topic.task?.owner?.name ||
+        topic.solution?.owner?.name ||
+        '');
+}
+export function getTopicText(topic) {
+    const primary = [
+        topic.title,
+        topic.talk?.text,
+        topic.question?.text,
+        topic.answer?.text,
+        topic.task?.text,
+        topic.solution?.text,
+    ].find(value => typeof value === 'string' && value.trim());
+    return (primary || '').replace(/\s+/g, ' ').trim();
+}
+export function getTopicUrl(topicId) {
+    return topicId ? `${SITE_URL}/topic/${topicId}` : SITE_URL;
+}
+export function summarizeComments(comments, limit = 3) {
+    return comments
+        .slice(0, limit)
+        .map((comment) => {
+        const author = comment.owner?.name || '匿名';
+        const target = comment.repliee?.name ? ` -> ${comment.repliee.name}` : '';
+        const text = (comment.text || '').replace(/\s+/g, ' ').trim();
+        return `${author}${target}: ${text}`;
+    })
+        .join(' | ');
+}
+export function toTopicRow(topic) {
+    const topicId = topic.topic_id ?? '';
+    const comments = pickArray(topic.show_comments, topic.comments);
+    return {
+        topic_id: topicId,
+        type: topic.type || '',
+        group: topic.group?.name || '',
+        author: getTopicAuthor(topic),
+        title: getTopicText(topic).slice(0, 120),
+        content: getTopicText(topic),
+        comments: topic.comments_count ?? comments.length ?? 0,
+        likes: topic.likes_count ?? 0,
+        readers: topic.readers_count ?? topic.reading_count ?? 0,
+        time: topic.create_time || '',
+        comment_preview: summarizeComments(comments),
+        url: getTopicUrl(topicId),
+    };
+}

package/dist/commanderAdapter.js

@@ -17,7 +17,7 @@ import { executeCommand } from './execution.js';
 import { CliError, EXIT_CODES, ERROR_ICONS, getErrorMessage, BrowserConnectError, AuthRequiredError, TimeoutError, SelectorError, EmptyResultError, ArgumentError, AdapterLoadError, CommandExecutionError, } from './errors.js';
 import { checkDaemonStatus } from './browser/discover.js';
 export function normalizeArgValue(argType, value, name) {
-    if (argType !== 'bool')
+    if (argType !== 'bool' && argType !== 'boolean')
         return value;
     if (typeof value === 'boolean')
         return value;
@@ -38,6 +38,8 @@ export function registerCommandToProgram(siteCmd, cmd) {
         return;
     const deprecatedSuffix = cmd.deprecated ? ' [deprecated]' : '';
     const subCmd = siteCmd.command(cmd.name).description(`${cmd.description}${deprecatedSuffix}`);
+    if (cmd.aliases?.length)
+        subCmd.aliases(cmd.aliases);
     // Register positional args first, then named options
     const positionalArgs = [];
     for (const arg of cmd.args) {
@@ -91,6 +93,9 @@ export function registerCommandToProgram(siteCmd, cmd) {
                 console.error(chalk.yellow(`Deprecated: ${message}${replacement}`));
             }
             const result = await executeCommand(cmd, kwargs, verbose);
+            if (result === null || result === undefined) {
+                return;
+            }
             if (verbose && (!result || (Array.isArray(result) && result.length === 0))) {
                 console.error(chalk.yellow('[Verbose] Warning: Command returned an empty result.'));
             }
@@ -274,7 +279,11 @@ async function renderError(err, cmdName, verbose) {
  * Register all commands from the registry onto a Commander program.
  */
 export function registerAllCommands(program, siteGroups) {
+    const seen = new Set();
     for (const [, cmd] of getRegistry()) {
+        if (seen.has(cmd))
+            continue;
+        seen.add(cmd);
         let siteCmd = siteGroups.get(cmd.site);
         if (!siteCmd) {
             siteCmd = program.command(cmd.site).description(`${cmd.site} commands`);

package/dist/commanderAdapter.test.js

@@ -60,3 +60,67 @@ describe('commanderAdapter arg passing', () => {
         expect(mockExecuteCommand).not.toHaveBeenCalled();
     });
 });
+describe('commanderAdapter boolean alias support', () => {
+    const cmd = {
+        site: 'reddit',
+        name: 'save',
+        description: 'Save a post',
+        browser: false,
+        args: [
+            { name: 'post-id', positional: true, required: true, help: 'Post ID' },
+            { name: 'undo', type: 'boolean', default: false, help: 'Unsave instead of save' },
+        ],
+        func: vi.fn(),
+    };
+    beforeEach(() => {
+        mockExecuteCommand.mockReset();
+        mockExecuteCommand.mockResolvedValue([]);
+        mockRenderOutput.mockReset();
+        delete process.env.OPENCLI_VERBOSE;
+        process.exitCode = undefined;
+    });
+    it('coerces default false for boolean args to a real boolean', async () => {
+        const program = new Command();
+        const siteCmd = program.command('reddit');
+        registerCommandToProgram(siteCmd, cmd);
+        await program.parseAsync(['node', 'opencli', 'reddit', 'save', 't3_abc123']);
+        expect(mockExecuteCommand).toHaveBeenCalled();
+        const kwargs = mockExecuteCommand.mock.calls[0][1];
+        expect(kwargs['post-id']).toBe('t3_abc123');
+        expect(kwargs.undo).toBe(false);
+    });
+    it('coerces explicit false for boolean args to a real boolean', async () => {
+        const program = new Command();
+        const siteCmd = program.command('reddit');
+        registerCommandToProgram(siteCmd, cmd);
+        await program.parseAsync(['node', 'opencli', 'reddit', 'save', 't3_abc123', '--undo', 'false']);
+        expect(mockExecuteCommand).toHaveBeenCalled();
+        const kwargs = mockExecuteCommand.mock.calls[0][1];
+        expect(kwargs.undo).toBe(false);
+    });
+});
+describe('commanderAdapter command aliases', () => {
+    const cmd = {
+        site: 'notebooklm',
+        name: 'get',
+        aliases: ['metadata'],
+        description: 'Get notebook metadata',
+        browser: false,
+        args: [],
+        func: vi.fn(),
+    };
+    beforeEach(() => {
+        mockExecuteCommand.mockReset();
+        mockExecuteCommand.mockResolvedValue([]);
+        mockRenderOutput.mockReset();
+        delete process.env.OPENCLI_VERBOSE;
+        process.exitCode = undefined;
+    });
+    it('registers aliases with Commander so compatibility names execute the same command', async () => {
+        const program = new Command();
+        const siteCmd = program.command('notebooklm');
+        registerCommandToProgram(siteCmd, cmd);
+        await program.parseAsync(['node', 'opencli', 'notebooklm', 'metadata']);
+        expect(mockExecuteCommand).toHaveBeenCalledWith(cmd, {}, false);
+    });
+});

package/dist/commands/daemon.d.ts

@@ -0,0 +1,9 @@
+/**
+ * CLI commands for daemon lifecycle management:
+ *   opencli daemon status  — show daemon state
+ *   opencli daemon stop    — graceful shutdown
+ *   opencli daemon restart — stop + respawn
+ */
+export declare function daemonStatus(): Promise<void>;
+export declare function daemonStop(): Promise<void>;
+export declare function daemonRestart(): Promise<void>;

package/dist/commands/daemon.js

@@ -0,0 +1,124 @@
+/**
+ * CLI commands for daemon lifecycle management:
+ *   opencli daemon status  — show daemon state
+ *   opencli daemon stop    — graceful shutdown
+ *   opencli daemon restart — stop + respawn
+ */
+import chalk from 'chalk';
+import { DEFAULT_DAEMON_PORT } from '../constants.js';
+const DAEMON_PORT = parseInt(process.env.OPENCLI_DAEMON_PORT ?? String(DEFAULT_DAEMON_PORT), 10);
+const DAEMON_URL = `http://127.0.0.1:${DAEMON_PORT}`;
+async function fetchStatus() {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 2000);
+    try {
+        const res = await fetch(`${DAEMON_URL}/status`, {
+            headers: { 'X-OpenCLI': '1' },
+            signal: controller.signal,
+        });
+        if (!res.ok)
+            return null;
+        return await res.json();
+    }
+    catch {
+        return null;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+async function requestShutdown() {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 5000);
+    try {
+        const res = await fetch(`${DAEMON_URL}/shutdown`, {
+            method: 'POST',
+            headers: { 'X-OpenCLI': '1' },
+            signal: controller.signal,
+        });
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+function formatUptime(seconds) {
+    const h = Math.floor(seconds / 3600);
+    const m = Math.floor((seconds % 3600) / 60);
+    if (h > 0)
+        return `${h}h ${m}m`;
+    if (m > 0)
+        return `${m}m`;
+    return `${Math.floor(seconds)}s`;
+}
+function formatTimeSince(timestampMs) {
+    const seconds = (Date.now() - timestampMs) / 1000;
+    if (seconds < 60)
+        return `${Math.floor(seconds)}s ago`;
+    const m = Math.floor(seconds / 60);
+    if (m < 60)
+        return `${m} min ago`;
+    const h = Math.floor(m / 60);
+    return `${h}h ${m % 60}m ago`;
+}
+export async function daemonStatus() {
+    const status = await fetchStatus();
+    if (!status) {
+        console.log(`Daemon: ${chalk.dim('not running')}`);
+        return;
+    }
+    console.log(`Daemon: ${chalk.green('running')} (PID ${status.pid})`);
+    console.log(`Uptime: ${formatUptime(status.uptime)}`);
+    console.log(`Extension: ${status.extensionConnected ? chalk.green('connected') : chalk.yellow('disconnected')}`);
+    console.log(`Last CLI request: ${formatTimeSince(status.lastCliRequestTime)}`);
+    console.log(`Memory: ${status.memoryMB} MB`);
+    console.log(`Port: ${status.port}`);
+}
+export async function daemonStop() {
+    const status = await fetchStatus();
+    if (!status) {
+        console.log(chalk.dim('Daemon is not running.'));
+        return;
+    }
+    const ok = await requestShutdown();
+    if (ok) {
+        console.log(chalk.green('Daemon stopped.'));
+    }
+    else {
+        console.error(chalk.red('Failed to stop daemon.'));
+        process.exitCode = 1;
+    }
+}
+export async function daemonRestart() {
+    const status = await fetchStatus();
+    if (status) {
+        const ok = await requestShutdown();
+        if (!ok) {
+            console.error(chalk.red('Failed to stop daemon.'));
+            process.exitCode = 1;
+            return;
+        }
+        // Wait for daemon to actually exit (poll until unreachable)
+        const deadline = Date.now() + 5000;
+        while (Date.now() < deadline) {
+            await new Promise(r => setTimeout(r, 200));
+            if (!(await fetchStatus()))
+                break;
+        }
+    }
+    // Import BrowserBridge to spawn a new daemon
+    const { BrowserBridge } = await import('../browser/mcp.js');
+    const bridge = new BrowserBridge();
+    try {
+        console.log('Starting daemon...');
+        await bridge.connect({ timeout: 10 });
+        console.log(chalk.green('Daemon restarted.'));
+    }
+    catch (err) {
+        console.error(chalk.red(`Failed to restart daemon: ${err instanceof Error ? err.message : err}`));
+        process.exitCode = 1;
+    }
+}

package/dist/commands/daemon.test.d.ts

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