@web-auto/webauto 0.1.4 → 0.1.7

package/dist/modules/collection-manager/storage.js

@@ -0,0 +1,195 @@
+"use strict";
+/**
+ * File storage utilities for collection data
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CollectionStorage = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class CollectionStorage {
+    baseDir;
+    collectionDir;
+    platform;
+    env;
+    collectionId;
+    constructor(baseDir, platform, env, collectionId) {
+        this.baseDir = baseDir;
+        this.platform = platform;
+        this.env = env;
+        this.collectionId = collectionId;
+        // Directory structure: baseDir/platform/env/collectionId/
+        this.collectionDir = path.join(baseDir, platform, env, collectionId);
+    }
+    /**
+     * Initialize storage directories
+     */
+    async init() {
+        await fs.promises.mkdir(this.collectionDir, { recursive: true });
+    }
+    /**
+     * Get paths for different files
+     */
+    getMetaPath() {
+        return path.join(this.collectionDir, 'collection-meta.json');
+    }
+    getPostsPath() {
+        return path.join(this.collectionDir, 'posts.jsonl');
+    }
+    getCommentsPath() {
+        return path.join(this.collectionDir, 'comments.jsonl');
+    }
+    getLinksPath() {
+        return path.join(this.collectionDir, 'links.jsonl');
+    }
+    getRunLogPath() {
+        return path.join(this.collectionDir, 'run.log');
+    }
+    getEventsPath() {
+        return path.join(this.collectionDir, 'run-events.jsonl');
+    }
+    /**
+     * Read/write meta
+     */
+    async readMeta() {
+        const metaPath = this.getMetaPath();
+        try {
+            const data = await fs.promises.readFile(metaPath, 'utf-8');
+            return JSON.parse(data);
+        }
+        catch {
+            return null;
+        }
+    }
+    async writeMeta(meta) {
+        const metaPath = this.getMetaPath();
+        await fs.promises.writeFile(metaPath, JSON.stringify(meta, null, 2), 'utf-8');
+    }
+    /**
+     * Append post to JSONL
+     */
+    async appendPost(post) {
+        const line = JSON.stringify(post) + '\n';
+        await fs.promises.appendFile(this.getPostsPath(), line, 'utf-8');
+    }
+    /**
+     * Append comment to JSONL
+     */
+    async appendComment(comment) {
+        const line = JSON.stringify(comment) + '\n';
+        await fs.promises.appendFile(this.getCommentsPath(), line, 'utf-8');
+    }
+    /**
+     * Read all posts
+     */
+    async readPosts() {
+        try {
+            const data = await fs.promises.readFile(this.getPostsPath(), 'utf-8');
+            return data.trim().split('\n').map(line => JSON.parse(line));
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * Read all comments
+     */
+    async readComments() {
+        try {
+            const data = await fs.promises.readFile(this.getCommentsPath(), 'utf-8');
+            return data.trim().split('\n').map(line => JSON.parse(line));
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * Count lines in JSONL file
+     */
+    async countLines(filePath) {
+        try {
+            const data = await fs.promises.readFile(filePath, 'utf-8');
+            return data.trim().split('\n').filter(line => line.length > 0).length;
+        }
+        catch {
+            return 0;
+        }
+    }
+    /**
+     * Get collection stats
+     */
+    async getStats() {
+        return {
+            postCount: await this.countLines(this.getPostsPath()),
+            commentCount: await this.countLines(this.getCommentsPath())
+        };
+    }
+    /**
+     * Clear all collection data (for fresh mode)
+     */
+    async clear() {
+        const files = [
+            this.getPostsPath(),
+            this.getCommentsPath(),
+            this.getLinksPath(),
+            this.getEventsPath()
+        ];
+        for (const file of files) {
+            try {
+                await fs.promises.unlink(file);
+            }
+            catch {
+                // File might not exist
+            }
+        }
+    }
+    /**
+     * List all collections for a platform/env
+     */
+    static async listCollections(baseDir, platform, env) {
+        const dir = path.join(baseDir, platform, env);
+        try {
+            const entries = await fs.promises.readdir(dir, { withFileTypes: true });
+            return entries
+                .filter(e => e.isDirectory())
+                .map(e => e.name);
+        }
+        catch {
+            return [];
+        }
+    }
+}
+exports.CollectionStorage = CollectionStorage;
+//# sourceMappingURL=storage.js.map

package/dist/modules/collection-manager/types.js

@@ -0,0 +1,47 @@
+"use strict";
+/** Collection types for unified data management across platforms */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildCollectionId = buildCollectionId;
+exports.parseCollectionId = parseCollectionId;
+/**
+ * Build collection ID from spec
+ */
+function buildCollectionId(spec) {
+    switch (spec.source) {
+        case 'search':
+            return `search:${spec.keyword}`;
+        case 'timeline':
+            return `timeline:${spec.date}`;
+        case 'user':
+            const safeName = spec.userName?.replace(/[\/\\:*?"<>|]/g, '_') || 'unknown';
+            return `user:${spec.userId}:${safeName}`;
+        case 'note':
+            return `note:${spec.noteId}`;
+        case 'product':
+            return `product:${spec.keyword}`;
+    }
+}
+/**
+ * Parse collection ID back to spec
+ */
+function parseCollectionId(id) {
+    const parts = id.split(':');
+    if (parts.length < 2)
+        return null;
+    const source = parts[0];
+    switch (source) {
+        case 'search':
+            return { source: 'search', keyword: parts.slice(1).join(':') };
+        case 'timeline':
+            return { source: 'timeline', date: parts[1] };
+        case 'user':
+            return { source: 'user', userId: parts[1], userName: parts[2] };
+        case 'note':
+            return { source: 'note', noteId: parts[1] };
+        case 'product':
+            return { source: 'product', keyword: parts.slice(1).join(':') };
+        default:
+            return null;
+    }
+}
+//# sourceMappingURL=types.js.map

package/dist/modules/logging/src/index.js

@@ -36,7 +36,7 @@ export function logDebug(module, event, data = {}) {
         data,
     };
     try {
-        fs.appendFileSync(DEBUG_LOG_FILE, `${JSON.stringify(entry)}\n`);
+        fs.appendFileSync(DEBUG_LOG_FILE, `${JSON.stringify(entry)}\n`, 'utf8');
     }
     catch {
         // ignore

package/dist/modules/process-registry/index.js

@@ -0,0 +1,230 @@
+/**
+ * ProcessRegistry - 进程生命周期管理
+ */
+import os from 'node:os';
+import path from 'node:path';
+import { promises as fs } from 'node:fs';
+import { execSync } from 'node:child_process';
+const DEFAULT_CONFIG = {
+    heartbeatIntervalMs: 30000,
+    staleTimeoutMs: 120000,
+    cleanupIntervalMs: 60000,
+};
+function resolveRegistryPath() {
+    const home = process.env.HOME || process.env.USERPROFILE || os.homedir();
+    return path.join(home, '.webauto', 'process-registry.json');
+}
+export class ProcessRegistry {
+    static instance = null;
+    entries = new Map();
+    registryPath;
+    config;
+    ownPid;
+    heartbeatTimer = null;
+    cleanupTimer = null;
+    initialized = false;
+    shutdownHandlersRegistered = false;
+    constructor(config = {}) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+        this.registryPath = resolveRegistryPath();
+        this.ownPid = process.pid;
+    }
+    static getInstance(config) {
+        if (!ProcessRegistry.instance) {
+            ProcessRegistry.instance = new ProcessRegistry(config);
+        }
+        return ProcessRegistry.instance;
+    }
+    async init() {
+        if (this.initialized)
+            return;
+        try {
+            const content = await fs.readFile(this.registryPath, 'utf-8');
+            const data = JSON.parse(content);
+            for (const entry of Object.values(data)) {
+                this.entries.set(entry.pid, entry);
+            }
+            console.log('[ProcessRegistry] Loaded', this.entries.size, 'entries');
+        }
+        catch {
+            // 无记录
+        }
+        this.startCleanupTimer();
+        this.initialized = true;
+    }
+    async register(type, profileId, metadata) {
+        await this.init();
+        const entry = {
+            pid: this.ownPid,
+            type,
+            profileId,
+            keyword: metadata?.keyword,
+            startedAt: Date.now(),
+            lastHeartbeat: Date.now(),
+            status: 'running',
+            metadata,
+        };
+        this.entries.set(this.ownPid, entry);
+        await this.persist();
+        console.log(`[ProcessRegistry] Registered: pid=${this.ownPid} type=${type} profile=${profileId}`);
+        this.startHeartbeat();
+        // 注册一次 exit 处理器
+        if (!this.shutdownHandlersRegistered) {
+            this.registerShutdownHandlers();
+            this.shutdownHandlersRegistered = true;
+        }
+        return this.ownPid;
+    }
+    registerShutdownHandlers() {
+        const handler = async () => {
+            await this.unregister();
+        };
+        process.once('SIGINT', handler);
+        process.once('SIGTERM', handler);
+        process.once('beforeExit', handler);
+    }
+    heartbeat() {
+        const entry = this.entries.get(this.ownPid);
+        if (entry) {
+            entry.lastHeartbeat = Date.now();
+            entry.status = 'running';
+            this.persist().catch(() => { });
+        }
+    }
+    async unregister() {
+        if (!this.entries.has(this.ownPid))
+            return;
+        this.stopHeartbeat();
+        this.entries.delete(this.ownPid);
+        await this.persist();
+        console.log(`[ProcessRegistry] Unregistered: pid=${this.ownPid}`);
+    }
+    getAll() {
+        return Array.from(this.entries.values());
+    }
+    getRunning() {
+        return this.getAll().filter(e => e.status === 'running');
+    }
+    async cleanStale() {
+        await this.init();
+        const now = Date.now();
+        const cleaned = [];
+        for (const [pid, entry] of this.entries) {
+            if (pid === this.ownPid)
+                continue;
+            if (now - entry.lastHeartbeat > this.config.staleTimeoutMs) {
+                entry.status = 'stale';
+                const isAlive = this.isProcessAlive(pid);
+                if (!isAlive) {
+                    this.entries.delete(pid);
+                    cleaned.push(`pid=${pid} (dead)`);
+                    await this.cleanupBrowserSession(entry.profileId);
+                }
+                else {
+                    console.log(`[ProcessRegistry] Killing stale process: pid=${pid} type=${entry.type}`);
+                    this.killProcess(pid);
+                    this.entries.delete(pid);
+                    cleaned.push(`pid=${pid} (killed)`);
+                    await this.cleanupBrowserSession(entry.profileId);
+                }
+            }
+        }
+        if (cleaned.length > 0) {
+            await this.persist();
+            console.log(`[ProcessRegistry] Cleaned ${cleaned.length} stale entries`);
+        }
+        return { cleaned: cleaned.length, killed: cleaned };
+    }
+    getStatus() {
+        const entry = this.entries.get(this.ownPid);
+        if (!entry)
+            return null;
+        return {
+            pid: entry.pid,
+            type: entry.type,
+            profileId: entry.profileId,
+            uptime: Date.now() - entry.startedAt,
+        };
+    }
+    startHeartbeat() {
+        if (this.heartbeatTimer)
+            return;
+        this.heartbeatTimer = setInterval(() => {
+            this.heartbeat();
+        }, this.config.heartbeatIntervalMs);
+        this.heartbeatTimer.unref();
+    }
+    stopHeartbeat() {
+        if (this.heartbeatTimer) {
+            clearInterval(this.heartbeatTimer);
+            this.heartbeatTimer = null;
+        }
+    }
+    startCleanupTimer() {
+        if (this.cleanupTimer)
+            return;
+        this.cleanupTimer = setInterval(() => {
+            this.cleanStale().catch(() => { });
+        }, this.config.cleanupIntervalMs);
+        this.cleanupTimer.unref();
+    }
+    isProcessAlive(pid) {
+        try {
+            process.kill(pid, 0);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    killProcess(pid) {
+        try {
+            if (process.platform === 'win32') {
+                execSync(`taskkill /PID ${pid} /T /F`, { stdio: 'ignore' });
+            }
+            else {
+                process.kill(pid, 'SIGTERM');
+                setTimeout(() => {
+                    if (this.isProcessAlive(pid)) {
+                        try {
+                            process.kill(pid, 'SIGKILL');
+                        }
+                        catch { }
+                    }
+                }, 5000);
+            }
+        }
+        catch { }
+    }
+    async cleanupBrowserSession(profileId) {
+        try {
+            execSync(`camo stop ${profileId}`, { stdio: 'ignore', timeout: 10000 });
+            console.log(`[ProcessRegistry] Cleaned browser: ${profileId}`);
+        }
+        catch { }
+    }
+    async persist() {
+        try {
+            const dir = path.dirname(this.registryPath);
+            await fs.mkdir(dir, { recursive: true });
+            const data = {};
+            for (const [pid, entry] of this.entries) {
+                data[pid] = entry;
+            }
+            await fs.writeFile(this.registryPath, JSON.stringify(data, null, 2), 'utf-8');
+        }
+        catch (err) {
+            console.error('[ProcessRegistry] Failed to persist:', err);
+        }
+    }
+    async shutdown() {
+        this.stopHeartbeat();
+        if (this.cleanupTimer) {
+            clearInterval(this.cleanupTimer);
+            this.cleanupTimer = null;
+        }
+        await this.unregister();
+    }
+}
+export const processRegistry = ProcessRegistry.getInstance();
+//# sourceMappingURL=index.js.map