qiksy 1.0.0

package/tools/work-finder/vendor/scripts/approver-mcp.mjs

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+/**
+ * Minimal MCP stdio server: permission-prompt handler for headless agents.
+ *
+ * The user's global ~/.claude/settings.json puts WebSearch/WebFetch in the
+ * "ask" list; in -p mode "ask" becomes "deny". This server is passed via
+ * `--permission-prompt-tool mcp__approver__approve` and auto-approves only
+ * the whitelisted tools below — everything else stays denied.
+ */
+const ALLOW = [/^WebSearch$/, /^WebFetch$/, /^ToolSearch$/, /^mcp__playwright__/];
+
+const send = msg => process.stdout.write(JSON.stringify(msg) + '\n');
+
+function handle(msg) {
+  const { id, method, params } = msg;
+  if (method === 'initialize') {
+    return send({
+      jsonrpc: '2.0', id,
+      result: {
+        protocolVersion: params?.protocolVersion || '2024-11-05',
+        capabilities: { tools: {} },
+        serverInfo: { name: 'approver', version: '1.0.0' },
+      },
+    });
+  }
+  if (method === 'tools/list') {
+    return send({
+      jsonrpc: '2.0', id,
+      result: {
+        tools: [{
+          name: 'approve',
+          description: 'Auto-approve permission prompts for whitelisted tools',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              tool_name: { type: 'string' },
+              input: { type: 'object' },
+              tool_use_id: { type: 'string' },
+            },
+            required: ['tool_name', 'input'],
+          },
+        }],
+      },
+    });
+  }
+  if (method === 'tools/call') {
+    const { name, arguments: args = {} } = params || {};
+    if (name !== 'approve') return send({ jsonrpc: '2.0', id, error: { code: -32601, message: 'unknown tool' } });
+    const ok = ALLOW.some(re => re.test(args.tool_name || ''));
+    const payload = ok
+      ? { behavior: 'allow', updatedInput: args.input || {} }
+      : { behavior: 'deny', message: `tool ${args.tool_name} is not whitelisted for work-finder agents` };
+    return send({ jsonrpc: '2.0', id, result: { content: [{ type: 'text', text: JSON.stringify(payload) }] } });
+  }
+  if (id !== undefined) send({ jsonrpc: '2.0', id, result: {} });
+}
+
+let buf = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', chunk => {
+  buf += chunk;
+  let nl;
+  while ((nl = buf.indexOf('\n')) >= 0) {
+    const line = buf.slice(0, nl).trim();
+    buf = buf.slice(nl + 1);
+    if (!line) continue;
+    try { handle(JSON.parse(line)); } catch { /* ignore malformed line */ }
+  }
+});

package/tools/work-finder/vendor/scripts/extract-linkedin.mjs

@@ -0,0 +1,81 @@
+#!/usr/bin/env node
+/**
+ * Extract a LinkedIn profile (own resume) via the CDP browser on :9222.
+ *
+ * Usage:
+ *   node scripts/extract-linkedin.mjs <profile-url> <output.txt>
+ *
+ * Opens NEW tabs in the already-running (logged-in) Chrome, reads the
+ * profile page + detail subpages, dumps raw visible text to <output.txt>.
+ * The user's own tabs are left untouched; new tabs are closed afterwards.
+ *
+ * Requires playwright-core; resolved from iucn-mono's node_modules to avoid
+ * an install here (override with PLAYWRIGHT_CORE env var).
+ */
+import { writeFileSync, mkdirSync } from 'node:fs';
+import { dirname } from 'node:path';
+
+const PW = process.env.PLAYWRIGHT_CORE
+  || '/Users/dimalesnak/Desktop/www/iucn-mono/node_modules/playwright-core/index.mjs';
+const { chromium } = await import(PW);
+
+const CDP = process.env.CDP_ENDPOINT || 'http://localhost:9222';
+const profileUrl = process.argv[2];
+const outFile = process.argv[3];
+if (!profileUrl || !outFile) {
+  console.error('Usage: node scripts/extract-linkedin.mjs <profile-url> <output.txt>');
+  process.exit(1);
+}
+
+const SUBPAGES = ['experience', 'education', 'skills', 'certifications', 'languages', 'projects'];
+
+const browser = await chromium.connectOverCDP(CDP);
+const context = browser.contexts()[0];
+if (!context) {
+  console.error('No browser context found on CDP endpoint.');
+  process.exit(1);
+}
+
+async function readPage(url) {
+  const page = await context.newPage();
+  try {
+    await page.goto(url, { waitUntil: 'domcontentloaded', timeout: 30_000 });
+    await page.waitForSelector('main', { timeout: 15_000 });
+    // LinkedIn lazy-loads sections on scroll — walk down the page.
+    await page.evaluate(async () => {
+      await new Promise(resolve => {
+        let last = -1;
+        const step = () => {
+          window.scrollBy(0, 700);
+          const y = window.scrollY;
+          if (y === last) return resolve();
+          last = y;
+          setTimeout(step, 250);
+        };
+        step();
+      });
+    });
+    await page.waitForLoadState('networkidle', { timeout: 10_000 }).catch(() => {});
+    return await page.evaluate(() => document.querySelector('main')?.innerText || '');
+  } catch (e) {
+    return `[extract error: ${e.message.split('\n')[0]}]`;
+  } finally {
+    await page.close().catch(() => {});
+  }
+}
+
+const base = profileUrl.replace(/\?.*$/, '').replace(/\/$/, '');
+let out = `SOURCE: ${base}\n\n===== MAIN PROFILE =====\n\n`;
+console.error('reading main profile…');
+out += await readPage(base + '/');
+
+for (const sub of SUBPAGES) {
+  console.error(`reading details/${sub}…`);
+  const text = await readPage(`${base}/details/${sub}/`);
+  out += `\n\n===== DETAILS: ${sub.toUpperCase()} =====\n\n${text}`;
+}
+
+mkdirSync(dirname(outFile), { recursive: true });
+writeFileSync(outFile, out, 'utf8');
+console.error(`saved ${out.length} chars -> ${outFile}`);
+await browser.close(); // detaches CDP connection only, Chrome keeps running

package/tools/work-finder/vendor/scripts/launch-browser.mjs

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+/**
+ * Ensure a CDP Chrome is up on :9222 (adapted from iucn-mono qa-kit).
+ *
+ * If something already listens on the port (e.g. the iucn-mono QA browser,
+ * where LinkedIn is logged in) — reuse it. Otherwise launch Chrome with
+ * work-finder's own persistent profile (.cdp-browser-profile/, git-ignored),
+ * so logins survive restarts.
+ *
+ * Env overrides: CHROME_PATH, PORT (default 9222), WF_HEADLESS=1
+ */
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { resolve, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const PORT = Number(process.env.PORT) || 9222;
+const ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+const PROFILE_DIR = resolve(ROOT, '.cdp-browser-profile');
+
+const CHROME_CANDIDATES = {
+  darwin: [
+    '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
+    '/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary',
+  ],
+  linux: ['/usr/bin/google-chrome', '/usr/bin/google-chrome-stable', '/usr/bin/chromium'],
+  win32: [
+    process.env.LOCALAPPDATA ? `${process.env.LOCALAPPDATA}\\Google\\Chrome\\Application\\chrome.exe` : null,
+    'C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe',
+  ].filter(Boolean),
+};
+
+async function probeCDP() {
+  try {
+    const res = await fetch(`http://localhost:${PORT}/json/version`, { signal: AbortSignal.timeout(1500) });
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+
+export async function ensureBrowser() {
+  if (await probeCDP()) {
+    console.error(`[browser] CDP already up on :${PORT}, reusing.`);
+    return true;
+  }
+  const chromePath = process.env.CHROME_PATH
+    || (CHROME_CANDIDATES[process.platform] || []).find(p => existsSync(p));
+  if (!chromePath) {
+    console.error('[browser] Chrome not found; set CHROME_PATH.');
+    return false;
+  }
+  const headless = /^(1|true)$/i.test(process.env.WF_HEADLESS || '');
+  const args = [
+    `--remote-debugging-port=${PORT}`,
+    `--user-data-dir=${PROFILE_DIR}`,
+    '--no-first-run',
+    ...(headless ? ['--headless=new', '--disable-gpu'] : []),
+  ];
+  console.error(`[browser] Launching Chrome${headless ? ' (headless)' : ''} on :${PORT}…`);
+  const child = spawn(chromePath, args, { detached: true, stdio: 'ignore' });
+  child.unref();
+  const t0 = Date.now();
+  while (Date.now() - t0 < 15_000) {
+    if (await probeCDP()) {
+      console.error('[browser] Ready.');
+      return true;
+    }
+    await new Promise(r => setTimeout(r, 300));
+  }
+  console.error(`[browser] Chrome did not respond on :${PORT} within 15s.`);
+  return false;
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const ok = await ensureBrowser();
+  process.exit(ok ? 0 : 1);
+}

package/tools/work-finder/vendor/scripts/screenshot.mjs

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+/** Open a URL in a new tab of the CDP browser, screenshot, close. Usage: node scripts/screenshot.mjs <url> <out.png> [width] */
+const PW = process.env.PLAYWRIGHT_CORE
+  || '/Users/dimalesnak/Desktop/www/iucn-mono/node_modules/playwright-core/index.mjs';
+const { chromium } = await import(PW);
+
+const [url, out, width] = process.argv.slice(2);
+const browser = await chromium.connectOverCDP(process.env.CDP_ENDPOINT || 'http://localhost:9222');
+const context = browser.contexts()[0];
+const page = await context.newPage();
+await page.setViewportSize({ width: Number(width) || 1400, height: 950 });
+await page.goto(url, { waitUntil: 'networkidle', timeout: 20_000 }).catch(() => {});
+await page.waitForTimeout(800);
+await page.screenshot({ path: out, fullPage: false });
+await page.close();
+await browser.close();
+console.error('saved', out);