@web-auto/webauto 0.1.1 → 0.1.2

package/dist/services/unified-api/state-registry.js

@@ -0,0 +1,274 @@
+/**
+ * State Registry - Unified state management for WebAuto
+ *
+ * Records and exposes:
+ * - Service states (unified-api, browser-service, search-gate)
+ * - Session states (active browser sessions)
+ * - Environment states (build version, config paths, feature flags)
+ *
+ * Persistence: ~/.webauto/state/core-state.json
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+// ===== State Registry Class =====
+function resolveStatePaths() {
+    const home = os.homedir();
+    const stateDir = path.join(home, '.webauto', 'state');
+    const logDir = path.join(home, '.webauto', 'logs');
+    return {
+        home,
+        stateDir,
+        logDir,
+        stateFile: path.join(stateDir, 'core-state.json'),
+        logFile: path.join(logDir, 'state.jsonl'),
+    };
+}
+class StateRegistry {
+    state;
+    flushTimer;
+    constructor() {
+        // Ensure directories exist
+        const paths = resolveStatePaths();
+        fs.mkdirSync(paths.stateDir, { recursive: true });
+        fs.mkdirSync(paths.logDir, { recursive: true });
+        // Load or initialize state
+        this.state = this.loadState();
+        // Auto-flush every 30 seconds
+        this.flushTimer = setInterval(() => {
+            this.flush();
+        }, 30000);
+    }
+    /**
+     * Load state from file or create new
+     */
+    loadState() {
+        try {
+            const { stateFile } = resolveStatePaths();
+            if (fs.existsSync(stateFile)) {
+                const data = fs.readFileSync(stateFile, 'utf-8');
+                const parsed = JSON.parse(data);
+                // Validate and migrate if needed
+                return this.validateState(parsed);
+            }
+        }
+        catch (err) {
+            console.error('[StateRegistry] Failed to load state:', err);
+        }
+        // Return initial state
+        return {
+            services: {},
+            sessions: {},
+            env: {
+                configPaths: {},
+                featureFlags: {
+                    searchGateEnabled: true,
+                    viewportSafetyEnabled: true,
+                },
+            },
+            timestamp: new Date().toISOString(),
+        };
+    }
+    /**
+     * Validate and migrate state
+     */
+    validateState(raw) {
+        const state = {
+            services: raw.services || {},
+            sessions: raw.sessions || {},
+            env: raw.env || {
+                configPaths: {},
+                featureFlags: {
+                    searchGateEnabled: true,
+                    viewportSafetyEnabled: true,
+                },
+            },
+            timestamp: raw.timestamp || new Date().toISOString(),
+        };
+        // Ensure env fields exist
+        if (!state.env.configPaths) {
+            state.env.configPaths = {};
+        }
+        if (!state.env.featureFlags) {
+            state.env.featureFlags = {
+                searchGateEnabled: true,
+                viewportSafetyEnabled: true,
+            };
+        }
+        return state;
+    }
+    /**
+     * Get full state snapshot
+     */
+    getState() {
+        return {
+            ...this.state,
+            timestamp: new Date().toISOString(),
+        };
+    }
+    /**
+     * Update service state
+     */
+    updateServiceState(serviceKey, updates) {
+        const current = this.state.services[serviceKey] || {
+            name: serviceKey,
+            port: 0,
+            status: 'down',
+            healthy: false,
+        };
+        this.state.services[serviceKey] = {
+            ...current,
+            ...updates,
+            lastHealthAt: updates.healthy ? new Date().toISOString() : current.lastHealthAt,
+        };
+        this.state.timestamp = new Date().toISOString();
+        this.logChange('service', serviceKey, updates);
+    }
+    /**
+     * Update session state
+     */
+    updateSessionState(profileId, updates) {
+        const current = this.state.sessions[profileId] || {
+            profileId,
+            lastActiveAt: new Date().toISOString(),
+            createdAt: new Date().toISOString(),
+            status: 'running',
+        };
+        this.state.sessions[profileId] = {
+            ...current,
+            ...updates,
+            lastActiveAt: new Date().toISOString(),
+        };
+        this.state.timestamp = new Date().toISOString();
+        this.logChange('session', profileId, updates);
+    }
+    /**
+     * Remove session state
+     */
+    removeSessionState(profileId) {
+        delete this.state.sessions[profileId];
+        this.state.timestamp = new Date().toISOString();
+        this.logChange('session', profileId, { action: 'removed' });
+    }
+    /**
+     * Update environment state
+     */
+    updateEnvState(updates) {
+        this.state.env = {
+            ...this.state.env,
+            ...updates,
+        };
+        if (updates.configPaths) {
+            this.state.env.configPaths = {
+                ...this.state.env.configPaths,
+                ...updates.configPaths,
+            };
+        }
+        if (updates.featureFlags) {
+            this.state.env.featureFlags = {
+                ...this.state.env.featureFlags,
+                ...updates.featureFlags,
+            };
+        }
+        this.state.timestamp = new Date().toISOString();
+        this.logChange('env', 'global', updates);
+    }
+    /**
+     * Get session state
+     */
+    getSessionState(profileId) {
+        return this.state.sessions[profileId];
+    }
+    /**
+     * Get all session states
+     */
+    getAllSessionStates() {
+        return { ...this.state.sessions };
+    }
+    /**
+     * Get service states
+     */
+    getServiceStates() {
+        return { ...this.state.services };
+    }
+    /**
+     * Get environment state
+     */
+    getEnvState() {
+        return { ...this.state.env };
+    }
+    /**
+     * Flush state to disk
+     */
+    flush() {
+        try {
+            const { stateFile, stateDir } = resolveStatePaths();
+            fs.mkdirSync(stateDir, { recursive: true });
+            fs.writeFileSync(stateFile, JSON.stringify(this.state, null, 2), 'utf-8');
+        }
+        catch (err) {
+            console.error('[StateRegistry] Failed to flush state:', err);
+        }
+    }
+    /**
+     * Log state change to jsonl file
+     */
+    logChange(type, key, changes) {
+        const entry = {
+            timestamp: new Date().toISOString(),
+            type,
+            key,
+            changes,
+        };
+        try {
+            const { logFile, logDir } = resolveStatePaths();
+            fs.mkdirSync(logDir, { recursive: true });
+            fs.appendFileSync(logFile, JSON.stringify(entry) + '\n', 'utf-8');
+        }
+        catch (err) {
+            console.error('[StateRegistry] Failed to log change:', err);
+        }
+    }
+    /**
+     * Cleanup old sessions (inactive for > 24 hours)
+     */
+    cleanupOldSessions() {
+        const now = Date.now();
+        const dayMs = 24 * 60 * 60 * 1000;
+        let cleaned = 0;
+        for (const [profileId, session] of Object.entries(this.state.sessions)) {
+            const lastActive = new Date(session.lastActiveAt).getTime();
+            if (now - lastActive > dayMs) {
+                delete this.state.sessions[profileId];
+                cleaned++;
+            }
+        }
+        if (cleaned > 0) {
+            console.log(`[StateRegistry] Cleaned up ${cleaned} old sessions`);
+            this.state.timestamp = new Date().toISOString();
+            this.flush();
+        }
+    }
+    /**
+     * Shutdown and cleanup
+     */
+    shutdown() {
+        if (this.flushTimer) {
+            clearInterval(this.flushTimer);
+        }
+        this.flush();
+    }
+}
+// Singleton instance
+let registryInstance = null;
+let registryHome = null;
+export function getStateRegistry() {
+    const currentHome = os.homedir();
+    if (!registryInstance || registryHome !== currentHome) {
+        registryInstance = new StateRegistry();
+        registryHome = currentHome;
+    }
+    return registryInstance;
+}
+export { StateRegistry };
+//# sourceMappingURL=state-registry.js.map

package/dist/services/unified-api/task-persistence.js

@@ -0,0 +1,66 @@
+// services/unified-api/task-persistence.ts
+// Simple JSONL persistence for task state (webauto-04b)
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+const STATE_DIR = path.join(os.homedir(), '.webauto', 'state');
+export async function ensureStateDir() {
+    await fs.mkdir(STATE_DIR, { recursive: true });
+}
+export async function saveTaskSnapshot(task) {
+    await ensureStateDir();
+    const file = path.join(STATE_DIR, `${task.runId}.json`);
+    await fs.writeFile(file, JSON.stringify(task, null, 2), 'utf8');
+}
+export async function loadTaskSnapshot(runId) {
+    try {
+        const file = path.join(STATE_DIR, `${runId}.json`);
+        const raw = await fs.readFile(file, 'utf8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+export async function appendEvent(event) {
+    await ensureStateDir();
+    const file = path.join(STATE_DIR, `${event.runId}.events.jsonl`);
+    await fs.appendFile(file, JSON.stringify(event) + '\n', 'utf8');
+}
+export async function loadEvents(runId, since) {
+    try {
+        const file = path.join(STATE_DIR, `${runId}.events.jsonl`);
+        const raw = await fs.readFile(file, 'utf8');
+        const lines = raw.trim().split('\n');
+        const events = lines.map(line => JSON.parse(line));
+        if (!since)
+            return events;
+        return events.filter(e => e.timestamp > since);
+    }
+    catch {
+        return [];
+    }
+}
+export async function deleteTaskFiles(runId) {
+    const snapshotFile = path.join(STATE_DIR, `${runId}.json`);
+    const eventsFile = path.join(STATE_DIR, `${runId}.events.jsonl`);
+    await Promise.all([
+        fs.unlink(snapshotFile).catch(() => { }),
+        fs.unlink(eventsFile).catch(() => { }),
+    ]);
+}
+export async function loadAllTasks() {
+    await ensureStateDir();
+    const files = await fs.readdir(STATE_DIR);
+    const tasks = [];
+    for (const file of files) {
+        if (!file.endsWith('.json') || file.includes('.events.'))
+            continue;
+        const runId = file.replace('.json', '');
+        const task = await loadTaskSnapshot(runId);
+        if (task)
+            tasks.push(task);
+    }
+    return tasks;
+}
+//# sourceMappingURL=task-persistence.js.map

package/dist/services/unified-api/task-state.js

@@ -0,0 +1,130 @@
+// services/unified-api/task-state.ts
+// Unified task state registry for UI ↔ script data sync (webauto-04b)
+class TaskStateRegistry {
+    tasks = new Map();
+    events = new Map();
+    subscribers = new Set();
+    maxEventsPerTask = 100;
+    createTask(partial) {
+        const now = Date.now();
+        const task = {
+            runId: partial.runId,
+            profileId: partial.profileId,
+            keyword: partial.keyword,
+            phase: partial.phase || 'unknown',
+            status: 'starting',
+            progress: { total: 0, processed: 0, failed: 0 },
+            stats: {
+                notesProcessed: 0,
+                commentsCollected: 0,
+                likesPerformed: 0,
+                repliesGenerated: 0,
+                imagesDownloaded: 0,
+                ocrProcessed: 0,
+            },
+            startedAt: now,
+            updatedAt: now,
+            details: {
+                recentEvents: [],
+            },
+        };
+        this.tasks.set(task.runId, task);
+        this.events.set(task.runId, []);
+        this.broadcast({ runId: task.runId, type: 'status_change', data: { status: 'starting' }, timestamp: now });
+        return task;
+    }
+    getTask(runId) {
+        return this.tasks.get(runId);
+    }
+    getAllTasks() {
+        return Array.from(this.tasks.values());
+    }
+    updateTask(runId, updates) {
+        const task = this.tasks.get(runId);
+        if (!task)
+            return undefined;
+        Object.assign(task, updates, { updatedAt: Date.now() });
+        this.tasks.set(runId, task);
+        return task;
+    }
+    updateProgress(runId, progress) {
+        const task = this.tasks.get(runId);
+        if (!task)
+            return;
+        Object.assign(task.progress, progress);
+        task.updatedAt = Date.now();
+        this.broadcast({ runId, type: 'progress', data: task.progress, timestamp: task.updatedAt });
+    }
+    updateStats(runId, stats) {
+        const task = this.tasks.get(runId);
+        if (!task)
+            return;
+        Object.assign(task.stats, stats);
+        task.updatedAt = Date.now();
+        this.broadcast({ runId, type: 'stats', data: task.stats, timestamp: task.updatedAt });
+    }
+    pushEvent(runId, eventType, data) {
+        const task = this.tasks.get(runId);
+        if (!task)
+            return;
+        const event = { runId, type: eventType, data, timestamp: Date.now() };
+        let events = this.events.get(runId) || [];
+        events.push(event);
+        if (events.length > this.maxEventsPerTask) {
+            events = events.slice(-this.maxEventsPerTask);
+        }
+        this.events.set(runId, events);
+        if (task.details) {
+            task.details.recentEvents = events.slice(-50);
+        }
+        this.broadcast({ runId, type: 'event', data: event, timestamp: event.timestamp });
+    }
+    setStatus(runId, status) {
+        const task = this.tasks.get(runId);
+        if (!task)
+            return;
+        task.status = status;
+        task.updatedAt = Date.now();
+        if (status === 'completed' || status === 'failed' || status === 'aborted') {
+            task.completedAt = task.updatedAt;
+        }
+        this.broadcast({ runId, type: 'status_change', data: { status }, timestamp: task.updatedAt });
+    }
+    setError(runId, error) {
+        const task = this.tasks.get(runId);
+        if (!task)
+            return;
+        task.lastError = error;
+        task.updatedAt = Date.now();
+        this.broadcast({ runId, type: 'error', data: error, timestamp: task.updatedAt });
+    }
+    getEvents(runId, since) {
+        const events = this.events.get(runId) || [];
+        if (!since)
+            return events;
+        return events.filter(e => e.timestamp > since);
+    }
+    deleteTask(runId) {
+        this.events.delete(runId);
+        return this.tasks.delete(runId);
+    }
+    subscribe(callback) {
+        this.subscribers.add(callback);
+        return () => {
+            this.subscribers.delete(callback);
+        };
+    }
+    broadcast(update) {
+        for (const cb of this.subscribers) {
+            try {
+                cb(update);
+            }
+            catch (err) {
+                console.error('[TaskStateRegistry] subscriber error:', err);
+            }
+        }
+    }
+}
+export const taskStateRegistry = new TaskStateRegistry();
+export default taskStateRegistry;
+//# sourceMappingURL=task-state.js.map

package/modules/camo-runtime/src/autoscript/action-providers/xhs/search.mjs

@@ -88,10 +88,18 @@ export function buildOpenDetailScript(params = {}) {
 
     const state = loadState();
     if (!Array.isArray(state.visitedNoteIds)) state.visitedNoteIds = [];
+    const requestedKeyword = ${JSON.stringify(keyword)};
+    const mode = ${JSON.stringify(mode)};
+    const previousKeyword = String(state.keyword || '').trim();
+    if (mode === 'first') {
+      state.visitedNoteIds = [];
+    } else if (requestedKeyword && previousKeyword && requestedKeyword !== previousKeyword) {
+      state.visitedNoteIds = [];
+    }
     state.maxNotes = Number(${maxNotes});
-    if (${JSON.stringify(keyword)}) state.keyword = ${JSON.stringify(keyword)};
+    if (requestedKeyword) state.keyword = requestedKeyword;
 
-    if (${JSON.stringify(mode)} === 'next' && state.visitedNoteIds.length >= state.maxNotes) {
+    if (mode === 'next' && state.visitedNoteIds.length >= state.maxNotes) {
       throw new Error('AUTOSCRIPT_DONE_MAX_NOTES');
     }
 
@@ -107,7 +115,7 @@ export function buildOpenDetailScript(params = {}) {
     if (nodes.length === 0) throw new Error('NO_SEARCH_RESULT_ITEM');
 
     let next = null;
-    if (${JSON.stringify(mode)} === 'next') {
+    if (mode === 'next') {
       next = nodes.find((row) => !state.visitedNoteIds.includes(row.noteId));
       if (!next) throw new Error('AUTOSCRIPT_DONE_NO_MORE_NOTES');
     } else {
@@ -161,7 +169,7 @@ export function buildOpenDetailScript(params = {}) {
     saveState(state);
     return {
       opened: true,
-      source: ${JSON.stringify(mode)} === 'next' ? 'open_next_detail' : 'open_first_detail',
+      source: mode === 'next' ? 'open_next_detail' : 'open_first_detail',
       noteId: next.noteId,
       visited: state.visitedNoteIds.length,
       maxNotes: state.maxNotes,
@@ -171,4 +179,3 @@ export function buildOpenDetailScript(params = {}) {
     };
   })()`;
 }
-

package/modules/xiaohongshu/app/pnpm-lock.yaml

@@ -0,0 +1,24 @@
+lockfileVersion: '9.0'
+
+settings:
+  autoInstallPeers: true
+  excludeLinksFromLockfile: false
+
+importers:
+
+  .:
+    devDependencies:
+      typescript:
+        specifier: ^5.0.0
+        version: 5.9.3
+
+packages:
+
+  typescript@5.9.3:
+    resolution: {integrity: sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==}
+    engines: {node: '>=14.17'}
+    hasBin: true
+
+snapshots:
+
+  typescript@5.9.3: {}

package/package.json

@@ -1,25 +1,53 @@
 {
   "name": "@web-auto/webauto",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "type": "module",
   "bin": {
     "webauto": "bin/webauto.mjs"
   },
+  "files": [
+    "bin/",
+    "dist/",
+    "modules/",
+    "scripts/",
+    "services/",
+    "apps/desktop-console/dist/",
+    "apps/desktop-console/default-settings.json",
+    "apps/desktop-console/entry/ui-console.mjs",
+    "apps/webauto/",
+    "!dist/**/*.map",
+    "!dist/**/__tests__/**",
+    "!dist/**/tests/**",
+    "!dist/**/*.test.*",
+    "!dist/**/*.spec.*",
+    "!modules/**/node_modules/**",
+    "!modules/**/__tests__/**",
+    "!modules/**/tests/**",
+    "!modules/**/*.test.*",
+    "!modules/**/*.spec.*",
+    "!modules/**/*.map",
+    "!services/**/__tests__/**",
+    "!services/**/tests/**",
+    "!services/**/*.test.*",
+    "!services/**/*.spec.*",
+    "!services/**/*.map",
+    "!apps/desktop-console/dist/**/*.map"
+  ],
   "dependencies": {
-    "@web-auto/camo": "^0.1.3",
-    "ajv": "^8.12.0",
+    "@web-auto/camo": "^0.1.6",
+    "ajv": "^8.18.0",
     "esbuild-register": "^3.6.0",
     "iconv-lite": "^0.6.3",
     "linkedom": "^0.18.12",
     "minimist": "^1.2.8",
     "node-fetch": "^2.7.0",
     "sharp": "^0.33.5",
-    "undici": "^7.16.0",
-    "ws": "^8.18.3"
+    "undici": "^7.22.0",
+    "ws": "^8.19.0"
   },
   "scripts": {
     "start:mcp:browser": "npx @browsermcp/mcp@latest",
-    "build": "npm run prebuild && npm run build:services && npm run self-check:post-build && npm run ui:test",
+    "build": "npm run prebuild && npm run build:services && npm run self-check:post-build && npm run ui:test && npm --prefix apps/desktop-console run build",
     "build:services": "tsc -p tsconfig.services.json",
     "self-check:post-build": "node scripts/self-check.mjs --quick --post-build",
     "start": "node dist/apps/webauto/server.js",
@@ -52,15 +80,15 @@
     "test:services:unit": "npx tsx --test $(find services -name \"*.test.ts\" -o -name \"*.test.mts\" 2>/dev/null | tr \"\\n\" \" \")"
   },
   "devDependencies": {
-    "@modelcontextprotocol/sdk": "^1.20.1",
+    "@modelcontextprotocol/sdk": "^1.26.0",
     "@types/express": "^5.0.6",
     "@types/minimist": "^1.2.5",
-    "@types/node": "^24.10.1",
+    "@types/node": "^24.10.13",
     "@types/ws": "^8.18.1",
     "c8": "^10.1.0",
     "camoufox": "^0.1.19",
     "json-schema-to-typescript": "^15.0.4",
-    "playwright": "^1.57.0",
+    "playwright": "^1.58.2",
     "ts-node": "^10.9.2",
     "tsx": "^4.16.5",
     "typescript": "^5.9.3"

package/.beads/README.md

@@ -1,81 +0,0 @@
-# Beads - AI-Native Issue Tracking
-
-Welcome to Beads! This repository uses **Beads** for issue tracking - a modern, AI-native tool designed to live directly in your codebase alongside your code.
-
-## What is Beads?
-
-Beads is issue tracking that lives in your repo, making it perfect for AI coding agents and developers who want their issues close to their code. No web UI required - everything works through the CLI and integrates seamlessly with git.
-
-**Learn more:** [github.com/steveyegge/beads](https://github.com/steveyegge/beads)
-
-## Quick Start
-
-### Essential Commands
-
-```bash
-# Create new issues
-bd create "Add user authentication"
-
-# View all issues
-bd list
-
-# View issue details
-bd show <issue-id>
-
-# Update issue status
-bd update <issue-id> --status in_progress
-bd update <issue-id> --status done
-
-# Sync with git remote
-bd sync
-```
-
-### Working with Issues
-
-Issues in Beads are:
-- **Git-native**: Stored in `.beads/issues.jsonl` and synced like code
-- **AI-friendly**: CLI-first design works perfectly with AI coding agents
-- **Branch-aware**: Issues can follow your branch workflow
-- **Always in sync**: Auto-syncs with your commits
-
-## Why Beads?
-
-✨ **AI-Native Design**
-- Built specifically for AI-assisted development workflows
-- CLI-first interface works seamlessly with AI coding agents
-- No context switching to web UIs
-
-🚀 **Developer Focused**
-- Issues live in your repo, right next to your code
-- Works offline, syncs when you push
-- Fast, lightweight, and stays out of your way
-
-🔧 **Git Integration**
-- Automatic sync with git commits
-- Branch-aware issue tracking
-- Intelligent JSONL merge resolution
-
-## Get Started with Beads
-
-Try Beads in your own projects:
-
-```bash
-# Install Beads
-curl -sSL https://raw.githubusercontent.com/steveyegge/beads/main/scripts/install.sh | bash
-
-# Initialize in your repo
-bd init
-
-# Create your first issue
-bd create "Try out Beads"
-```
-
-## Learn More
-
-- **Documentation**: [github.com/steveyegge/beads/docs](https://github.com/steveyegge/beads/tree/main/docs)
-- **Quick Start Guide**: Run `bd quickstart`
-- **Examples**: [github.com/steveyegge/beads/examples](https://github.com/steveyegge/beads/tree/main/examples)
-
----
-
-*Beads: Issue tracking that moves at the speed of thought* ⚡