@web-auto/camo 0.1.3 → 0.1.4

package/src/commands/browser.mjs

@@ -4,6 +4,7 @@ import { callAPI, ensureCamoufox, ensureBrowserService, getSessionByProfile, che
 import { resolveProfileId, ensureUrlScheme, looksLikeUrlToken, getPositionals } from '../utils/args.mjs';
 import { acquireLock, releaseLock, isLocked, getLockInfo, cleanupStaleLocks } from '../lifecycle/lock.mjs';
 import { registerSession, updateSession, getSessionInfo, unregisterSession, listRegisteredSessions, markSessionClosed, cleanupStaleSessions, recoverSession } from '../lifecycle/session-registry.mjs';
+import { startSessionWatchdog, stopAllSessionWatchdogs, stopSessionWatchdog } from '../lifecycle/session-watchdog.mjs';
 
 export async function handleStartCommand(args) {
   ensureCamoufox();
@@ -56,6 +57,7 @@ export async function handleStartCommand(args) {
       message: 'Session already running',
       url: existing.current_url,
     }, null, 2));
+    startSessionWatchdog(profileId);
     return;
   }
 
@@ -84,6 +86,7 @@ export async function handleStartCommand(args) {
       url: targetUrl,
       headless,
     });
+    startSessionWatchdog(profileId);
   }
   console.log(JSON.stringify(result, null, 2));
 }
@@ -92,10 +95,20 @@ export async function handleStopCommand(args) {
   await ensureBrowserService();
   const profileId = resolveProfileId(args, 1, getDefaultProfile);
   if (!profileId) throw new Error('Usage: camo stop [profileId]');
-  
-  const result = await callAPI('stop', { profileId });
-  releaseLock(profileId);
-  markSessionClosed(profileId);
+
+  let result = null;
+  let stopError = null;
+  try {
+    result = await callAPI('stop', { profileId });
+  } catch (err) {
+    stopError = err;
+  } finally {
+    stopSessionWatchdog(profileId);
+    releaseLock(profileId);
+    markSessionClosed(profileId);
+  }
+
+  if (stopError) throw stopError;
   console.log(JSON.stringify(result, null, 2));
 }
 
@@ -405,6 +418,7 @@ export async function handleShutdownCommand() {
     } catch {
       // Best effort cleanup
     }
+    stopSessionWatchdog(session.profileId);
     releaseLock(session.profileId);
     markSessionClosed(session.profileId);
   }
@@ -413,10 +427,12 @@ export async function handleShutdownCommand() {
   const registered = listRegisteredSessions();
   for (const reg of registered) {
     if (reg.status !== 'closed') {
+      stopSessionWatchdog(reg.profileId);
       markSessionClosed(reg.profileId);
       releaseLock(reg.profileId);
     }
   }
+  stopAllSessionWatchdogs();
   
   const result = await callAPI('service:shutdown', {});
   console.log(JSON.stringify(result, null, 2));

package/src/commands/container.mjs

@@ -1,124 +1,328 @@
-// Container commands - filter and watch elements
-import { resolveProfileId, getPositionals } from '../utils/args.mjs';
-import { callAPI, getSessionByProfile } from '../utils/browser-service.mjs';
+// Container commands - filter, watch, and subscription targets
+import { getDomSnapshotByProfile, getSessionByProfile, getViewportByProfile } from '../utils/browser-service.mjs';
 import { getDefaultProfile } from '../utils/config.mjs';
 import { getChangeNotifier } from '../container/change-notifier.mjs';
 import { createElementFilter } from '../container/element-filter.mjs';
+import {
+  getRegisteredTargets,
+  initContainerSubscriptionDirectory,
+  listSubscriptionSets,
+  registerSubscriptionTargets,
+} from '../container/subscription-registry.mjs';
+import { safeAppendProgressEvent } from '../events/progress-log.mjs';
 
 const notifier = getChangeNotifier();
 const elementFilter = createElementFilter();
 
-export async function handleContainerFilterCommand(args) {
-  const profileId = resolveProfileId(args);
+const VALUE_FLAGS = new Set([
+  '--profile',
+  '-p',
+  '--selector',
+  '-s',
+  '--throttle',
+  '-t',
+  '--source',
+  '--site',
+]);
+
+function readFlagValue(args, names) {
+  for (let i = 0; i < args.length; i += 1) {
+    if (!names.includes(args[i])) continue;
+    const value = args[i + 1];
+    if (!value || String(value).startsWith('-')) return null;
+    return value;
+  }
+  return null;
+}
+
+function collectPositionals(args, startIndex = 2) {
+  const out = [];
+  for (let i = startIndex; i < args.length; i += 1) {
+    const arg = args[i];
+    if (!arg) continue;
+    if (VALUE_FLAGS.has(arg)) {
+      i += 1;
+      continue;
+    }
+    if (String(arg).startsWith('-')) continue;
+    out.push(arg);
+  }
+  return out;
+}
+
+async function ensureSession(profileId) {
   const session = await getSessionByProfile(profileId);
   if (!session) {
     throw new Error(`No active session for profile: ${profileId || 'default'}`);
   }
+  return session;
+}
 
-  const selectors = [];
-  for (let i = 1; i < args.length; i++) {
-    const arg = args[i];
-    if (arg === '--profile' || arg === '-p') { i++; continue; }
-    if (arg.startsWith('--')) continue;
-    selectors.push(arg);
+function resolveWatchProfileAndSelectors(args) {
+  const explicitProfile = readFlagValue(args, ['--profile', '-p']);
+  const explicitSelector = readFlagValue(args, ['--selector', '-s']);
+  const positionals = collectPositionals(args);
+
+  if (explicitSelector) {
+    const profileId = explicitProfile || positionals[0] || getDefaultProfile();
+    return { profileId, selectors: [explicitSelector], source: 'manual' };
+  }
+
+  if (explicitProfile) {
+    return {
+      profileId: explicitProfile,
+      selectors: positionals,
+      source: positionals.length > 0 ? 'manual' : 'subscription',
+    };
+  }
+
+  if (positionals.length >= 2) {
+    return { profileId: positionals[0], selectors: positionals.slice(1), source: 'manual' };
+  }
+
+  if (positionals.length === 1) {
+    const candidateProfile = getRegisteredTargets(positionals[0])?.profile;
+    if (candidateProfile) {
+      return { profileId: positionals[0], selectors: [], source: 'subscription' };
+    }
+    return { profileId: getDefaultProfile(), selectors: [positionals[0]], source: 'manual' };
+  }
+
+  return { profileId: getDefaultProfile(), selectors: [], source: 'subscription' };
+}
+
+function resolveProfileAndSelectors(args) {
+  const explicitProfile = readFlagValue(args, ['--profile', '-p']);
+  const positionals = collectPositionals(args);
+  if (explicitProfile) {
+    return { profileId: explicitProfile, selectors: positionals };
+  }
+  if (positionals.length >= 2) {
+    return { profileId: positionals[0], selectors: positionals.slice(1) };
+  }
+  return { profileId: getDefaultProfile(), selectors: positionals };
+}
+
+function resolveListProfile(args) {
+  const explicitProfile = readFlagValue(args, ['--profile', '-p']);
+  if (explicitProfile) return explicitProfile;
+  const positionals = collectPositionals(args);
+  return positionals[0] || getDefaultProfile();
+}
+
+export async function handleContainerInitCommand(args) {
+  const source = readFlagValue(args, ['--source']);
+  const force = args.includes('--force');
+  const result = initContainerSubscriptionDirectory({
+    ...(source ? { containerLibraryRoot: source } : {}),
+    force,
+  });
+  console.log(JSON.stringify(result, null, 2));
+}
+
+export async function handleContainerSetsCommand(args) {
+  const site = readFlagValue(args, ['--site']);
+  const result = listSubscriptionSets({ ...(site ? { site } : {}) });
+  console.log(JSON.stringify(result, null, 2));
+}
+
+export async function handleContainerRegisterCommand(args) {
+  const explicitProfile = readFlagValue(args, ['--profile', '-p']);
+  const append = args.includes('--append');
+  const positionals = collectPositionals(args);
+
+  let profileId;
+  let setIds;
+  if (explicitProfile) {
+    profileId = explicitProfile;
+    setIds = positionals;
+  } else if (positionals.length >= 2) {
+    profileId = positionals[0];
+    setIds = positionals.slice(1);
+  } else {
+    profileId = getDefaultProfile();
+    setIds = positionals;
+  }
+
+  if (!profileId) {
+    throw new Error('Usage: camo container register [profileId] <setId...> [--append] [--profile <id>]');
+  }
+  if (!Array.isArray(setIds) || setIds.length === 0) {
+    throw new Error('Usage: camo container register [profileId] <setId...> [--append] [--profile <id>]');
   }
 
+  const result = registerSubscriptionTargets(profileId, setIds, { append });
+  console.log(JSON.stringify(result, null, 2));
+}
+
+export async function handleContainerTargetsCommand(args) {
+  const explicitProfile = readFlagValue(args, ['--profile', '-p']);
+  const positionals = collectPositionals(args);
+  const profileId = explicitProfile || positionals[0] || null;
+  const result = getRegisteredTargets(profileId);
+  console.log(JSON.stringify(result, null, 2));
+}
+
+export async function handleContainerFilterCommand(args) {
+  const { profileId, selectors } = resolveProfileAndSelectors(args);
+  if (!profileId) {
+    throw new Error('Usage: camo container filter [profileId] <selector...> [--profile <id>]');
+  }
   if (selectors.length === 0) {
-    throw new Error('Usage: camo container filter <selector> [--profile <id>]');
+    throw new Error('Usage: camo container filter [profileId] <selector...> [--profile <id>]');
   }
 
-  // Get DOM snapshot from browser service
-  const result = await callAPI(`/session/${session.session_id}/dom-tree`, { method: 'POST' });
-  const snapshot = result.dom_tree || result;
+  const session = await ensureSession(profileId);
+  const snapshot = await getDomSnapshotByProfile(session.profileId || profileId);
 
-  // Filter elements
   const matched = [];
   for (const selector of selectors) {
     const elements = notifier.findElements(snapshot, { css: selector });
-    matched.push(...elements.map(e => ({
-      path: e.path,
-      tag: e.tag,
-      id: e.id,
-      classes: e.classes,
-      text: (e.textSnippet || e.text || '').slice(0, 50),
-    })));
+    matched.push(
+      ...elements.map((element) => ({
+        selector,
+        path: element.path,
+        tag: element.tag,
+        id: element.id,
+        classes: element.classes,
+        text: (element.textSnippet || element.text || '').slice(0, 80),
+      })),
+    );
   }
 
-  console.log(JSON.stringify({ ok: true, count: matched.length, elements: matched }, null, 2));
+  console.log(JSON.stringify({ ok: true, profileId: session.profileId || profileId, count: matched.length, elements: matched }, null, 2));
 }
 
 export async function handleContainerWatchCommand(args) {
-  const profileId = resolveProfileId(args);
-  const session = await getSessionByProfile(profileId);
-  if (!session) {
-    throw new Error(`No active session for profile: ${profileId || 'default'}`);
+  const watchRequest = resolveWatchProfileAndSelectors(args);
+  const profileId = watchRequest.profileId;
+  if (!profileId) {
+    throw new Error(
+      'Usage: camo container watch [profileId] [--selector <css>|<selector...>] [--throttle ms] [--profile <id>]',
+    );
   }
 
-  const positionalArgs = getPositionals(args, ['--profile', '-p', '--selector', '-s', '--throttle', '-t']);
-  
-  const selectorIdx = args.indexOf('--selector') !== -1 ? args.indexOf('--selector') : args.indexOf('-s');
-  const throttleIdx = args.indexOf('--throttle') !== -1 ? args.indexOf('--throttle') : args.indexOf('-t');
-  
-  const selector = selectorIdx >= 0 ? args[selectorIdx + 1] : positionalArgs[0];
-  const throttle = throttleIdx >= 0 ? parseInt(args[throttleIdx + 1], 10) : 500;
+  let selectors = Array.from(
+    new Set(
+      (watchRequest.selectors || [])
+        .map((item) => String(item || '').trim())
+        .filter(Boolean),
+    ),
+  );
+  let source = watchRequest.source;
+
+  if (selectors.length === 0) {
+    const registered = getRegisteredTargets(profileId)?.profile;
+    selectors = Array.from(
+      new Set(
+        (registered?.selectors || [])
+          .map((item) => item?.css)
+          .filter((css) => typeof css === 'string' && css.trim())
+          .map((css) => css.trim()),
+      ),
+    );
+    source = 'subscription';
+  }
 
-  if (!selector) {
-    throw new Error('Usage: camo container watch --selector <css> [--throttle ms] [--profile <id>]');
+  if (selectors.length === 0) {
+    throw new Error(
+      `No selectors found for profile: ${profileId}. Use --selector <css> or run camo container register ${profileId} <setId...> first.`,
+    );
   }
 
-  console.log(JSON.stringify({ ok: true, message: `Watching selector: ${selector}`, throttle }));
+  const session = await ensureSession(profileId);
+  const throttleRaw = readFlagValue(args, ['--throttle', '-t']);
+  const throttle = Math.max(100, Number(throttleRaw) || 500);
+
+  console.log(JSON.stringify({
+    ok: true,
+    message: `Watching ${selectors.length} selector(s) from ${source}`,
+    selectors,
+    profileId: session.profileId || profileId,
+    throttle,
+  }));
+  safeAppendProgressEvent({
+    source: 'container.watch',
+    mode: 'normal',
+    profileId: session.profileId || profileId,
+    event: 'container.watch.start',
+    payload: {
+      selectors,
+      throttle,
+      source,
+    },
+  });
 
-  // Setup WebSocket connection for DOM updates
-  // For now, poll the browser service
   const interval = setInterval(async () => {
     try {
-      const result = await callAPI(`/session/${session.session_id}/dom-tree`, { method: 'POST' });
-      const snapshot = result.dom_tree || result;
+      const snapshot = await getDomSnapshotByProfile(session.profileId || profileId);
       notifier.processSnapshot(snapshot);
     } catch (err) {
-      console.error(JSON.stringify({ ok: false, error: err.message }));
+      console.error(JSON.stringify({ ok: false, error: err?.message || String(err) }));
     }
   }, throttle);
 
-  // Watch the selector
-  notifier.watch({ css: selector }, {
+  const watchers = selectors.map((selector) => notifier.watch({ css: selector }, {
     onAppear: (elements) => {
       console.log(JSON.stringify({ event: 'appear', selector, count: elements.length, elements }));
+      safeAppendProgressEvent({
+        source: 'container.watch',
+        mode: 'normal',
+        profileId: session.profileId || profileId,
+        event: 'container.appear',
+        payload: { selector, count: elements.length },
+      });
     },
     onDisappear: (elements) => {
       console.log(JSON.stringify({ event: 'disappear', selector, count: elements.length }));
+      safeAppendProgressEvent({
+        source: 'container.watch',
+        mode: 'normal',
+        profileId: session.profileId || profileId,
+        event: 'container.disappear',
+        payload: { selector, count: elements.length },
+      });
     },
     onChange: ({ appeared, disappeared }) => {
       console.log(JSON.stringify({ event: 'change', selector, appeared: appeared.length, disappeared: disappeared.length }));
+      safeAppendProgressEvent({
+        source: 'container.watch',
+        mode: 'normal',
+        profileId: session.profileId || profileId,
+        event: 'container.change',
+        payload: { selector, appeared: appeared.length, disappeared: disappeared.length },
+      });
     },
     throttle,
-  });
+  }));
 
-  // Keep process alive
-  process.on('SIGINT', () => {
+  process.once('SIGINT', () => {
     clearInterval(interval);
+    for (const stopWatch of watchers) stopWatch();
     notifier.destroy();
     console.log(JSON.stringify({ ok: true, message: 'Watch stopped' }));
+    safeAppendProgressEvent({
+      source: 'container.watch',
+      mode: 'normal',
+      profileId: session.profileId || profileId,
+      event: 'container.watch.stop',
+      payload: { selectors },
+    });
     process.exit(0);
   });
 }
 
 export async function handleContainerListCommand(args) {
-  const profileId = resolveProfileId(args);
-  const session = await getSessionByProfile(profileId);
-  if (!session) {
-    throw new Error(`No active session for profile: ${profileId || 'default'}`);
+  const profileId = resolveListProfile(args);
+  if (!profileId) {
+    throw new Error('Usage: camo container list [profileId] [--profile <id>]');
   }
+  const session = await ensureSession(profileId);
 
-  const result = await callAPI(`/session/${session.session_id}/dom-tree`, { method: 'POST' });
-  const snapshot = result.dom_tree || result;
-
-  // Get viewport info
-  const viewportResult = await callAPI(`/session/${session.session_id}/viewport`);
-  const viewport = viewportResult.viewport || { width: 1280, height: 720 };
+  const snapshot = await getDomSnapshotByProfile(session.profileId || profileId);
+  const viewport = await getViewportByProfile(session.profileId || profileId);
 
-  // Collect all visible elements
-  const collectElements = (node, path = 'root') => {
+  const collectElements = (node, domPath = 'root') => {
     const elements = [];
     if (!node) return elements;
 
@@ -126,10 +330,9 @@ export async function handleContainerListCommand(args) {
     if (rect && viewport) {
       const inViewport = elementFilter.isInViewport(rect, viewport);
       const visibilityRatio = elementFilter.getVisibilityRatio(rect, viewport);
-
       if (inViewport && visibilityRatio > 0.1) {
         elements.push({
-          path,
+          path: domPath,
           tag: node.tag,
           id: node.id,
           classes: node.classes?.slice(0, 3),
@@ -139,9 +342,9 @@ export async function handleContainerListCommand(args) {
       }
     }
 
-    if (node.children) {
-      for (let i = 0; i < node.children.length; i++) {
-        elements.push(...collectElements(node.children[i], `${path}/${i}`));
+    if (Array.isArray(node.children)) {
+      for (let i = 0; i < node.children.length; i += 1) {
+        elements.push(...collectElements(node.children[i], `${domPath}/${i}`));
       }
     }
 
@@ -149,30 +352,50 @@ export async function handleContainerListCommand(args) {
   };
 
   const elements = collectElements(snapshot);
-  console.log(JSON.stringify({ ok: true, viewport, count: elements.length, elements: elements.slice(0, 50) }, null, 2));
+  console.log(JSON.stringify({
+    ok: true,
+    profileId: session.profileId || profileId,
+    viewport,
+    count: elements.length,
+    elements: elements.slice(0, 50),
+  }, null, 2));
 }
 
 export async function handleContainerCommand(args) {
   const sub = args[1];
 
   switch (sub) {
+    case 'init':
+      return handleContainerInitCommand(args);
+    case 'sets':
+      return handleContainerSetsCommand(args);
+    case 'register':
+      return handleContainerRegisterCommand(args);
+    case 'targets':
+      return handleContainerTargetsCommand(args);
     case 'filter':
-      return handleContainerFilterCommand(args.slice(1));
+      return handleContainerFilterCommand(args);
     case 'watch':
-      return handleContainerWatchCommand(args.slice(1));
+      return handleContainerWatchCommand(args);
     case 'list':
-      return handleContainerListCommand(args.slice(1));
+      return handleContainerListCommand(args);
     default:
-      console.log(`Usage: camo container <filter|watch|list> [options]
+      console.log(`Usage: camo container <init|sets|register|targets|filter|watch|list> [options]
 
 Commands:
-  filter <selector>  - Filter DOM elements by CSS selector
-  watch --selector <css> - Watch for element changes (outputs JSON events)
-  list               - List all visible elements in viewport
+  init [--source <container-library-dir>] [--force]         Initialize subscription directory and migrate container sets
+  sets [--site <siteKey>]                                    List migrated subscription sets
+  register [profileId] <setId...> [--append]                Register subscription targets for profile
+  targets [profileId]                                        Show registered targets
+  filter [profileId] <selector...>                           Filter DOM elements by CSS selector
+  watch [profileId] [--selector <css>] [--throttle <ms>]     Watch for element changes (defaults to registered selectors)
+  list [profileId]                                           List visible elements in viewport
 
 Options:
-  --profile, -p <id>  - Profile to use
-  --throttle, -t <ms> - Throttle interval for watch (default: 500)
+  --profile, -p <id>                                         Profile to use
+  --selector, -s <css>                                       Selector for watch
+  --throttle, -t <ms>                                        Poll interval for watch (default: 500)
+  --site <siteKey>                                           Filter set list by site
 `);
   }
 }