npm - @reshotdev/screenshot - Versions diffs - 0.0.1-beta.0 - Mend

@reshotdev/screenshot 0.0.1-beta.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (59) hide show

package/LICENSE +190 -0
package/README.md +388 -0
package/package.json +64 -0
package/src/commands/auth.js +259 -0
package/src/commands/chrome.js +140 -0
package/src/commands/ci-run.js +123 -0
package/src/commands/ci-setup.js +288 -0
package/src/commands/drifts.js +423 -0
package/src/commands/import-tests.js +309 -0
package/src/commands/ingest.js +458 -0
package/src/commands/init.js +633 -0
package/src/commands/publish.js +1721 -0
package/src/commands/pull.js +303 -0
package/src/commands/record.js +94 -0
package/src/commands/run.js +476 -0
package/src/commands/setup-wizard.js +740 -0
package/src/commands/setup.js +137 -0
package/src/commands/status.js +275 -0
package/src/commands/sync.js +621 -0
package/src/commands/ui.js +248 -0
package/src/commands/validate-docs.js +529 -0
package/src/index.js +462 -0
package/src/lib/api-client.js +815 -0
package/src/lib/capture-engine.js +1623 -0
package/src/lib/capture-script-runner.js +3120 -0
package/src/lib/ci-detect.js +137 -0
package/src/lib/config.js +1240 -0
package/src/lib/diff-engine.js +642 -0
package/src/lib/hash.js +74 -0
package/src/lib/image-crop.js +396 -0
package/src/lib/matrix.js +89 -0
package/src/lib/output-path-template.js +318 -0
package/src/lib/playwright-runner.js +252 -0
package/src/lib/polished-clip.js +553 -0
package/src/lib/privacy-engine.js +408 -0
package/src/lib/progress-tracker.js +142 -0
package/src/lib/record-browser-injection.js +654 -0
package/src/lib/record-cdp.js +612 -0
package/src/lib/record-clip.js +343 -0
package/src/lib/record-config.js +623 -0
package/src/lib/record-screenshot.js +360 -0
package/src/lib/record-terminal.js +123 -0
package/src/lib/recorder-service.js +781 -0
package/src/lib/secrets.js +51 -0
package/src/lib/selector-strategies.js +859 -0
package/src/lib/standalone-mode.js +400 -0
package/src/lib/storage-providers.js +569 -0
package/src/lib/style-engine.js +684 -0
package/src/lib/ui-api.js +4677 -0
package/src/lib/ui-assets.js +373 -0
package/src/lib/ui-executor.js +587 -0
package/src/lib/variant-injector.js +591 -0
package/src/lib/viewport-presets.js +454 -0
package/src/lib/worker-pool.js +118 -0
package/web/cropper/index.html +436 -0
package/web/manager/dist/assets/index--ZgioErz.js +507 -0
package/web/manager/dist/assets/index-n468W0Wr.css +1 -0
package/web/manager/dist/index.html +27 -0
package/web/subtitle-editor/index.html +295 -0

package/src/commands/auth.js ADDED Viewed

@@ -0,0 +1,259 @@
+const axios = require("axios");
+const chalk = require("chalk");
+const http = require("http");
+// `open` and `ora` are ESM-only in the versions we use; when required from CommonJS
+// their callable export is exposed on the `default` property.
+const openModule = require("open");
+const open = openModule.default || openModule;
+const oraModule = require("ora");
+const ora = oraModule.default || oraModule;
+const { writeSettings, SETTINGS_PATH, SETTINGS_DIR } = require("../lib/config");
+const { getApiBaseUrl } = require("../lib/api-client");
+const pkg = require("../../package.json");
+const DEFAULT_CALLBACK_PORT = 3721;
+const POLL_INTERVAL_MS = 2000;
+const unwrapResponse = (payload) => {
+  if (!payload) {
+    return {};
+  }
+  if (typeof payload === "object" && "data" in payload) {
+    return payload.data;
+  }
+  return payload;
+};
+function wait(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function startLocalStatusServer(requestedPort, options = {}) {
+  const { explicit = false } = options;
+  return new Promise((resolve, reject) => {
+    const server = http.createServer((req, res) => {
+      res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+      res.end(
+        `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <title>Reshot CLI Authentication</title>
+    <style>
+      body { font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; margin: 0; padding: 2rem; background: #0b1727; color: #f4f6fb; }
+      .card { max-width: 640px; margin: 0 auto; background: #111f33; border-radius: 16px; padding: 2rem; box-shadow: 0 20px 45px rgba(0,0,0,0.45); }
+      h1 { font-size: 1.5rem; margin-top: 0; }
+      p { line-height: 1.5; color: #d3d9e6; }
+      code { background: rgba(255,255,255,0.08); padding: 0.15rem 0.35rem; border-radius: 6px; }
+    </style>
+  </head>
+  <body>
+    <div class="card">
+      <h1>Waiting for CLI confirmation…</h1>
+      <p>Your browser session is connected to the Reshot CLI. You can close this tab once the CLI confirms that authentication is complete.</p>
+      <p>If you closed the terminal prompt, run <code>reshot auth</code> again to start a new session.</p>
+    </div>
+  </body>
+</html>`
+      );
+    });
+    server.on("error", (error) => {
+      if (error.code === "EADDRINUSE") {
+        // If the user explicitly requested this port via env, surface a clear,
+        // actionable error. Otherwise, just bubble up the code so the caller
+        // can fall back to another port.
+        if (explicit) {
+          const err = new Error(
+            `Port ${requestedPort} is already in use. Set RESHOT_CLI_CALLBACK_PORT to a free port and retry.`
+          );
+          err.code = error.code;
+          return reject(err);
+        }
+        const err = new Error(error.message);
+        err.code = error.code;
+        return reject(err);
+      }
+      reject(error);
+    });
+    server.listen(requestedPort, () => {
+      const address = server.address();
+      const actualPort =
+        typeof address === "object" &&
+        address &&
+        typeof address.port === "number"
+          ? address.port
+          : requestedPort;
+      resolve({ server, port: actualPort });
+    });
+  });
+}
+async function waitForCompletion(apiBaseUrl, authToken, expiresAtIso) {
+  const expiresAt = expiresAtIso
+    ? Date.parse(expiresAtIso)
+    : Date.now() + 5 * 60 * 1000;
+  const statusSpinner = ora("Waiting for browser authentication…").start();
+  try {
+    while (Date.now() < expiresAt) {
+      const statusResponse = await axios.get(`${apiBaseUrl}/auth/cli/status`, {
+        params: { token: authToken },
+      });
+      const payload = unwrapResponse(statusResponse.data);
+      const status = payload.status;
+      if (status === "completed" && payload.project?.apiKey) {
+        statusSpinner.succeed("Browser authentication confirmed");
+        return payload;
+      }
+      if (status === "expired") {
+        throw new Error(
+          "Authentication token expired. Run `reshot auth` again."
+        );
+      }
+      if (status === "invalid") {
+        throw new Error("Authentication session invalid. Start a new session.");
+      }
+      await wait(POLL_INTERVAL_MS);
+    }
+    throw new Error("Authentication timed out before completion.");
+  } catch (error) {
+    statusSpinner.fail("Browser authentication failed");
+    throw error;
+  }
+}
+async function verifyApiKey(apiBaseUrl, apiKey) {
+  await axios.get(`${apiBaseUrl}/auth/cli/verify`, {
+    headers: {
+      Authorization: `Bearer ${apiKey}`,
+    },
+  });
+}
+async function authCommand() {
+  const apiBaseUrl = getApiBaseUrl();
+  const explicitPortEnv =
+    process.env.RESHOT_CLI_CALLBACK_PORT ||
+    process.env.DOCSYNC_CLI_CALLBACK_PORT ||
+    "";
+  const basePort = parseInt(explicitPortEnv || `${DEFAULT_CALLBACK_PORT}`, 10);
+  const hasExplicitPort = Boolean(explicitPortEnv);
+  let localServer;
+  let callbackPort;
+  const spinner = ora("Requesting authentication session…").start();
+  try {
+    if (hasExplicitPort) {
+      // Respect an explicitly configured port and fail fast with a clear error
+      // if it is not available.
+      const { server, port } = await startLocalStatusServer(basePort, {
+        explicit: true,
+      });
+      localServer = server;
+      callbackPort = port;
+    } else {
+      // Default behaviour: try the default port first for a stable experience,
+      // but automatically fall back to any available port so users never have
+      // to think about port conflicts.
+      try {
+        const { server, port } = await startLocalStatusServer(basePort);
+        localServer = server;
+        callbackPort = port;
+      } catch (error) {
+        if (error && error.code === "EADDRINUSE") {
+          const { server, port } = await startLocalStatusServer(0);
+          localServer = server;
+          callbackPort = port;
+          console.log(
+            chalk.gray(
+              `Callback port ${basePort} is in use; using available port ${callbackPort} instead.`
+            )
+          );
+        } else {
+          throw error;
+        }
+      }
+    }
+    const initiateResponse = await axios.post(
+      `${apiBaseUrl}/auth/cli/initiate`,
+      {
+        callbackPort,
+        clientVersion: pkg.version,
+      },
+      { headers: { "Content-Type": "application/json" } }
+    );
+    const payload = unwrapResponse(initiateResponse.data);
+    const { authUrl, authToken, expiresAt } = payload;
+    if (!authUrl || !authToken) {
+      throw new Error("Authentication session did not return a URL or token.");
+    }
+    spinner.succeed("Authentication session created");
+    console.log(chalk.gray(`Token expires at ${expiresAt || "unknown time"}`));
+    console.log(chalk.gray(`Settings will be stored in ${SETTINGS_PATH}`));
+    await open(authUrl, { wait: false });
+    console.log(
+      chalk.blue(
+        "A browser window has been opened. Complete the flow to continue."
+      )
+    );
+    const status = await waitForCompletion(apiBaseUrl, authToken, expiresAt);
+    await verifyApiKey(apiBaseUrl, status.project.apiKey);
+    // Derive platformUrl from apiBaseUrl (remove /api suffix)
+    const platformUrl = apiBaseUrl.replace(/\/api\/?$/, '') || 'http://localhost:3000';
+    writeSettings({
+      projectId: status.project.id,
+      projectName: status.project.name,
+      apiKey: status.project.apiKey,
+      platformUrl: platformUrl,
+      workspace: status.project.workspace || null,
+      workspaceName: status.project.workspace?.name || null,
+      linkedAt: new Date().toISOString(),
+      cliVersion: pkg.version,
+      user: status.user
+        ? {
+            id: status.user.id,
+            email: status.user.email,
+            fullName: status.user.fullName,
+          }
+        : null,
+      settingsDir: SETTINGS_DIR,
+    });
+    console.log();
+    console.log(
+      chalk.green(
+        `✔ Reshot CLI is now linked to ${
+          status.project.workspace?.name || "your workspace"
+        } / ${status.project.name}`
+      )
+    );
+    console.log(chalk.gray(`Settings saved to ${SETTINGS_PATH}`));
+  } finally {
+    if (localServer) {
+      localServer.close();
+    }
+  }
+}
+module.exports = authCommand;

package/src/commands/chrome.js ADDED Viewed

@@ -0,0 +1,140 @@
+const chalk = require('chalk');
+const fs = require('fs-extra');
+const os = require('os');
+const path = require('path');
+const { spawn } = require('child_process');
+const DEFAULT_PORT = process.env.RESHOT_CHROME_PORT || '9222';
+const DEFAULT_URL = 'about:blank';
+const MAC_CANDIDATES = [
+  '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
+  '/Applications/Google Chrome Beta.app/Contents/MacOS/Google Chrome',
+  '/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary'
+];
+const WIN_CANDIDATES = [
+  path.join(process.env['PROGRAMFILES'] || 'C:\\Program Files', 'Google', 'Chrome', 'Application', 'chrome.exe'),
+  path.join(process.env['PROGRAMFILES(X86)'] || 'C:\\Program Files (x86)', 'Google', 'Chrome', 'Application', 'chrome.exe')
+];
+const LINUX_CANDIDATES = [
+  'google-chrome-stable',
+  'google-chrome',
+  'chromium-browser',
+  'chromium'
+];
+function getCandidates() {
+  const platform = process.platform;
+  if (platform === 'darwin') {
+    return MAC_CANDIDATES;
+  }
+  if (platform === 'win32') {
+    return WIN_CANDIDATES;
+  }
+  return LINUX_CANDIDATES;
+}
+function buildManualCommand(port) {
+  if (process.platform === 'darwin') {
+    return '/Applications/Google\\ Chrome.app/Contents/MacOS/Google\\ Chrome --remote-debugging-port=' + port;
+  }
+  if (process.platform === 'win32') {
+    return '"C:\\\\Program Files\\\\Google\\\\Chrome\\\\Application\\\\chrome.exe" --remote-debugging-port=' + port;
+  }
+  return `google-chrome --remote-debugging-port=${port}`;
+}
+function spawnChrome(executable, args) {
+  return new Promise((resolve) => {
+    let done = false;
+    try {
+      const child = spawn(executable, args, {
+        detached: true,
+        stdio: 'ignore',
+        windowsHide: true
+      });
+      child.once('error', (error) => {
+        if (done) return;
+        done = true;
+        resolve({ success: false, error });
+      });
+      child.unref();
+      setTimeout(() => {
+        if (!done) {
+          done = true;
+          resolve({ success: true });
+        }
+      }, 300);
+    } catch (error) {
+      resolve({ success: false, error });
+    }
+  });
+}
+async function chromeCommand(options = {}) {
+  const port = options.port || DEFAULT_PORT;
+  const targetUrl = options.url || DEFAULT_URL;
+  const homeDir = os.homedir();
+  const profileDir = path.join(homeDir, '.reshot', 'chrome-profile');
+  await fs.ensureDir(profileDir);
+  const chromeArgs = [
+    `--remote-debugging-port=${port}`,
+    '--remote-debugging-address=127.0.0.1',
+    '--no-first-run',
+    '--no-default-browser-check',
+    '--disable-popup-blocking',
+    '--disable-background-networking',
+    '--disable-component-extensions-with-background-pages',
+    `--user-data-dir=${profileDir}`
+  ];
+  if (targetUrl) {
+    chromeArgs.push(targetUrl);
+  }
+  const candidates = getCandidates();
+  const errors = [];
+  for (const executable of candidates) {
+    const isAbsolutePath = executable.includes('/') || executable.includes('\\');
+    if (isAbsolutePath && !fs.existsSync(executable)) {
+      continue;
+    }
+    // eslint-disable-next-line no-await-in-loop
+    const result = await spawnChrome(executable, chromeArgs);
+    if (result.success) {
+      console.log(chalk.green(`✔ Chrome launched with remote debugging on port ${port}`));
+      console.log(chalk.gray('Keep this Chrome window open while you run `reshot record`.'));
+      return;
+    }
+    errors.push({ executable, error: result.error });
+  }
+  console.error(chalk.red('✖ Unable to launch Chrome automatically.'));
+  if (errors.length > 0) {
+    errors.forEach(({ executable, error }) => {
+      console.error(chalk.gray(`  • ${executable}: ${error?.message || 'not found'}`));
+    });
+  }
+  console.log('');
+  console.log(chalk.yellow('You can launch Chrome manually with:'));
+  console.log(chalk.cyan(buildManualCommand(port)));
+  console.log('');
+  console.log(chalk.gray('After Chrome is running, continue with `reshot record`.'));
+}
+module.exports = chromeCommand;

package/src/commands/ci-run.js ADDED Viewed

@@ -0,0 +1,123 @@
+// ci-run.js - Composite command: run + publish in one step (CI-optimized)
+const chalk = require("chalk");
+const fs = require("fs-extra");
+const path = require("path");
+const { detectCI, getCIMetadata } = require("../lib/ci-detect");
+async function ciRunCommand(options = {}) {
+  const { config: configPath, tag, message, dryRun, publish: shouldPublish = true } = options;
+  // Disable colors in CI for cleaner logs
+  const { isCI, provider } = detectCI();
+  if (isCI) {
+    process.env.NO_COLOR = "1";
+  }
+  const ciMeta = getCIMetadata();
+  console.log(chalk.cyan("🤖 Reshot CI Run\n"));
+  if (isCI) {
+    console.log(chalk.gray(`  Provider: ${provider || "unknown"}`));
+    if (ciMeta.commitSha) {
+      console.log(chalk.gray(`  Commit: ${ciMeta.commitSha.slice(0, 8)}`));
+    }
+    if (ciMeta.branch) {
+      console.log(chalk.gray(`  Branch: ${ciMeta.branch}`));
+    }
+    console.log();
+  }
+  // Override config path if specified
+  if (configPath) {
+    process.env.RESHOT_CONFIG_PATH = configPath;
+  }
+  const ciResult = {
+    run: { success: false, scenariosRun: 0, scenariosFailed: 0 },
+    publish: null,
+    ci: ciMeta,
+    timestamp: new Date().toISOString(),
+  };
+  // Step 1: Run capture scenarios
+  console.log(chalk.cyan("━━━ Step 1: Capture ━━━\n"));
+  try {
+    const runCommand = require("./run");
+    const runResult = await runCommand({
+      headless: true,
+      noExit: true,
+    });
+    ciResult.run.success = runResult?.success ?? false;
+    if (runResult?.results) {
+      ciResult.run.scenariosRun = runResult.results.length;
+      ciResult.run.scenariosFailed = runResult.results.filter((r) => !r.success).length;
+    }
+  } catch (error) {
+    console.error(chalk.red(`Capture failed: ${error.message}`));
+    ciResult.run.success = false;
+    ciResult.run.error = error.message;
+  }
+  // Step 2: Publish (unless --no-publish or capture failed)
+  if (shouldPublish && ciResult.run.success) {
+    console.log(chalk.cyan("\n━━━ Step 2: Publish ━━━\n"));
+    try {
+      const publishCommand = require("./publish");
+      const publishResult = await publishCommand({
+        tag,
+        message: message || (ciMeta.commitSha ? `CI publish (${ciMeta.commitSha.slice(0, 8)})` : "CI publish"),
+        dryRun,
+        force: true, // Skip prompts in CI
+        outputJson: true,
+      });
+      ciResult.publish = {
+        success: (publishResult?.assetsFailed || 0) === 0,
+        assetsProcessed: publishResult?.assetsProcessed || 0,
+        assetsFailed: publishResult?.assetsFailed || 0,
+        assetsSkipped: publishResult?.assetsSkipped || 0,
+        viewUrl: publishResult?.viewUrl || null,
+      };
+    } catch (error) {
+      console.error(chalk.red(`Publish failed: ${error.message}`));
+      ciResult.publish = { success: false, error: error.message };
+    }
+  } else if (!shouldPublish) {
+    console.log(chalk.gray("\n  Skipping publish (--no-publish)"));
+  } else if (!ciResult.run.success) {
+    console.log(chalk.yellow("\n  Skipping publish (capture failed)"));
+  }
+  // Write composite result
+  const outputDir = path.join(process.cwd(), ".reshot", "output");
+  fs.ensureDirSync(outputDir);
+  const resultPath = path.join(outputDir, "ci-result.json");
+  fs.writeJsonSync(resultPath, ciResult, { spaces: 2 });
+  console.log(chalk.gray(`\n📄 CI result written to: ${resultPath}`));
+  // Summary
+  console.log(chalk.cyan("\n━━━ CI Summary ━━━\n"));
+  const runIcon = ciResult.run.success ? chalk.green("✔") : chalk.red("✖");
+  console.log(`  ${runIcon} Capture: ${ciResult.run.scenariosRun} scenario(s), ${ciResult.run.scenariosFailed} failed`);
+  if (ciResult.publish) {
+    const pubIcon = ciResult.publish.success ? chalk.green("✔") : chalk.red("✖");
+    console.log(`  ${pubIcon} Publish: ${ciResult.publish.assetsProcessed || 0} asset(s)`);
+    if (ciResult.publish.viewUrl) {
+      console.log(chalk.cyan(`  🔗 ${ciResult.publish.viewUrl}`));
+    }
+  }
+  console.log();
+  // Exit with appropriate code
+  const overallSuccess = ciResult.run.success && (!ciResult.publish || ciResult.publish.success);
+  if (!overallSuccess) {
+    process.exitCode = 1;
+  }
+  return ciResult;
+}
+module.exports = ciRunCommand;