backdraw 0.0.0-stage → 2.1.1

package/bin/backdraw.js

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+'use strict';
+// The `backdraw` command (npm package bin): setup, doctor, uninstall, and every cli.js command.
+//   npx backdraw@latest setup
+const readline = require('readline');
+const { parseArgs } = require('../lib/args');
+const cli = require('../cli');
+
+const VERSION = require('../package.json').version;
+
+const HELP = `Backdraw ${VERSION}: let Claude generate images with your own ChatGPT account in a background Chrome tab.
+
+Usage: backdraw <command>
+  setup [--yes] [--clients=a,b] [--browser=chrome|edge|brave|chromium] [--no-wait]
+                                  Install or update, register the browsers and MCP clients, load the extension
+                                  clients: claude-code, claude-desktop, codex, cursor, vscode, gemini
+  doctor [--fix]                  Check the install; --fix repairs registrations
+  uninstall [--dry-run]           Remove the registrations (your images and settings stay)
+  mcp                             Run the MCP server on stdio (what MCP clients start; needs setup once)
+  --version                       Print the version
+${cli.USAGE.split('\n').slice(1).join('\n')}`;
+
+// A question on the terminal, or no asking at all without one (setup then takes the found clients).
+function asker() {
+  if (!process.stdin.isTTY || !process.stdout.isTTY) return undefined;
+  return question => new Promise(resolve => {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    rl.on('SIGINT', () => { rl.close(); process.exit(130); });
+    rl.question(question, answer => { rl.close(); resolve(answer); });
+  });
+}
+
+async function main(argv) {
+  const [cmd, ...rest] = argv;
+  const { flags } = parseArgs(rest, { booleans: ['yes', 'fix', 'dry-run', 'no-wait'] });
+  switch (cmd) {
+    // stdout belongs to the JSON-RPC stream from here on; the server reads stdin until it closes.
+    case 'mcp':
+      return require('../mcp-server');
+    case '-v': case '--version': case 'version':
+      return console.log(VERSION);
+    case 'setup':
+      return require('../setup').setup({ yes: !!flags.yes, clients: flags.clients, browser: flags.browser, wait: !flags['no-wait'] }, { ask: flags.yes ? undefined : asker() });
+    case 'doctor': {
+      const checks = await require('../doctor').doctor({ fix: !!flags.fix });
+      if (checks.some(c => c.status === 'fail')) process.exitCode = 1;
+      return undefined;
+    }
+    case 'uninstall':
+      return require('../install').uninstall({ dryRun: !!flags['dry-run'] });
+    case undefined: case '-h': case '--help': case 'help':
+      return console.log(HELP);
+    default:
+      if (cli.COMMANDS.includes(cmd)) return cli.run(argv);
+      console.log(HELP);
+      throw new Error(`Unknown command "${cmd}".`);
+  }
+}
+
+main(process.argv.slice(2)).catch(e => { console.error(`Error: ${e.message}`); process.exitCode = 1; });

package/cli.js

@@ -0,0 +1,105 @@
+'use strict';
+// Command line access to the bridge, for setup and troubleshooting.
+const path = require('path');
+const bridge = require('./shared');
+const { parseArgs } = require('./lib/args');
+const { FINAL } = require('./lib/results');
+const { MAX_REFS } = require('./lib/limits');
+const { findCollection } = require('./lib/collections');
+
+const USAGE = `Usage: node cli.js <command>
+  status                          Bridge status (Chrome connected, selected project, queue)
+  projects                        List ChatGPT projects
+  select <name | link>            Select the project where images are generated
+  generate "<prompt>" [--ref IMAGE]... [--url CHAT_LINK] [--aspect W:H] [--transparent] [--reattach] [--out FOLDER] [--raw] [--wait 300]
+           [--collection NAME [--file FILE]...]
+                                  Generate an image; --ref attaches a reference/image to edit (up to ${MAX_REFS} in all);
+                                  --collection adds a reference collection's newest images (--file picks them);
+                                  --aspect 16:9 sets the shape (1:4 to 4:1), --transparent asks for a see-through background
+  collect <chat link> [--aspect W:H] [--out FOLDER]   Download the latest images of an existing chat (sends nothing), cropped to W:H
+  job <id> [--wait 60]            Show a job's status
+  cancel <id>                     Cancel a job
+  collections                     List the reference collections (Chrome: right-click an image, "Add to Backdraw")
+  collection <name>               Show one collection and its images
+  outdir <folder>                 Change the central images folder
+  debug on|off                    Verbose logging (logs/host.log)
+  diagnose [link] [--selector CSS] [--max N] [--worker]   Page diagnostics
+  reload                          Reload the Chrome extension`;
+
+const FLAGS = { booleans: ['raw', 'reattach', 'worker', 'transparent'], lists: ['ref', 'file'] };
+const sleep = ms => new Promise(r => setTimeout(r, ms));
+
+const print = v => console.log(JSON.stringify(v, null, 2));
+
+async function follow(jobId, waitSec) {
+  const deadline = Date.now() + waitSec * 1000;
+  let job = await bridge.call('job', { jobId });
+  let last = '';
+  for (;;) {
+    const note = `${job.status} | ${job.step} | ${job.message || ''}`;
+    if (note !== last) { console.error(`[${new Date().toLocaleTimeString()}] ${note}`); last = note; }
+    if (FINAL.has(job.status) || Date.now() > deadline) return bridge.copyResults(job);
+    await sleep(1500);
+    job = await bridge.call('job', { jobId });
+  }
+}
+
+// argv: the words after "node cli.js" (or "backdraw").
+async function run(argv) {
+  const [cmd, ...rest] = argv;
+  const { pos, flags } = parseArgs(rest, FLAGS);
+  const copyTo = typeof flags.out === 'string' ? path.resolve(flags.out) : undefined;
+  if (flags.aspect === true) throw new Error('--aspect needs a ratio, e.g. --aspect 16:9.');
+  switch (cmd) {
+    case 'status': return print(await bridge.call('status'));
+    case 'projects': return print(await bridge.call('list_projects', {}, 130000));
+    case 'select': {
+      const v = pos.join(' ');
+      if (!v) throw new Error('A project name or link is required.');
+      return print(await bridge.call('select_project', /^https?:\/\//i.test(v) ? { url: v } : { name: v }, 130000));
+    }
+    case 'generate': {
+      const prompt = pos.join(' ');
+      if (!prompt) throw new Error('A prompt is required.');
+      const job = await bridge.call('generate', {
+        prompt, copyTo, references: bridge.readReferences(flags.ref ? [].concat(flags.ref) : []),
+        startUrl: typeof flags.url === 'string' ? flags.url : undefined, sendAsIs: !!flags.raw, autoReattach: !!flags.reattach,
+        aspect: flags.aspect, transparent: !!flags.transparent,
+        referenceCollection: typeof flags.collection === 'string' ? flags.collection : undefined, referenceFiles: flags.file ? [].concat(flags.file) : undefined,
+      }, 60000);
+      console.error(`Job: ${job.id}`);
+      return print(await follow(job.id, Number(flags.wait) || 600));
+    }
+    case 'collect': {
+      if (!pos[0]) throw new Error('A chat link is required.');
+      const job = await bridge.call('generate', { mode: 'collect', startUrl: pos[0], copyTo, aspect: flags.aspect });
+      console.error(`Job: ${job.id}`);
+      return print(await follow(job.id, Number(flags.wait) || 300));
+    }
+    case 'job': return print(await follow(pos[0], Number(flags.wait) || 0));
+    case 'cancel': return print(await bridge.call('cancel', { jobId: pos[0] }));
+    case 'collections': return print(await bridge.call('list_collections', { summary: true }));
+    case 'collection': {
+      const name = pos.join(' ');
+      if (!name) throw new Error('A collection name is required.');
+      const list = await bridge.call('list_collections');
+      const { collection, error, ties } = findCollection(list, name);
+      if (error === 'AMBIGUOUS') throw new Error(`"${name}" matches several collections: ${ties.map(c => c.name).join(', ')}`);
+      if (error) throw new Error(`No collection matches "${name}". Available: ${list.map(c => c.name).join(', ') || '(none)'}`);
+      return print(collection);
+    }
+    case 'outdir': return print(await bridge.call('set_config', { outputDir: path.resolve(pos[0]) }));
+    case 'debug': return print(await bridge.call('set_config', { debug: pos[0] === 'on' }));
+    case 'diagnose':
+      return print(await bridge.call('diagnose', {
+        url: pos[0], selector: flags.selector, max: flags.max ? Number(flags.max) : undefined, target: flags.worker ? 'worker' : undefined,
+      }, 190000));
+    case 'reload': return print(await bridge.call('reload_extension'));
+    default:
+      console.log(USAGE);
+  }
+}
+
+if (require.main === module) run(process.argv.slice(2)).catch(e => { console.error(`Error: ${e.message}`); process.exitCode = 1; });
+
+module.exports = { USAGE, COMMANDS: ['status', 'projects', 'select', 'generate', 'collect', 'job', 'cancel', 'collections', 'collection', 'outdir', 'debug', 'diagnose', 'reload'], run };

package/doctor.js

@@ -0,0 +1,174 @@
+'use strict';
+// `backdraw doctor [--fix]`: gathers what can be checked about an install (files, host manifest,
+// browser registry keys and policies, the bridge, the extension, ChatGPT, the MCP clients), prints
+// it with lib/doctor.js, and with --fix repairs what is safe to repair: the host manifest, the
+// registry keys, and client entries that point to the wrong place.
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const identity = require('./identity');
+const installer = require('./install');
+const browsers = require('./lib/browsers');
+const mcpClients = require('./lib/mcp-clients');
+const report = require('./lib/doctor');
+const { useColor, painter, line } = require('./lib/term');
+
+const SELF = require('./package.json').version;
+// What an install needs to run; anything else in the folder is optional.
+const REQUIRED = ['package.json', 'identity.js', 'shared.js', 'host.js', 'mcp-server.js', 'cli.js', 'install.js',
+  path.join('extension', 'manifest.json'), path.join('platform', 'index.js'), 'lib'];
+
+function readJson(file) {
+  try { return JSON.parse(fs.readFileSync(file, 'utf8')); } catch { return null; }
+}
+
+function commandExists(p, cmd) {
+  if (typeof cmd !== 'string' || !cmd) return false;
+  return path.isAbsolute(cmd) ? fs.existsSync(cmd) : !!p.which(cmd);
+}
+
+// What is wrong with the host manifest, or null.
+function manifestProblem(json, dest) {
+  if (!json) return 'unreadable';
+  if (json.name !== identity.HOST_NAME) return `names ${json.name}, not ${identity.HOST_NAME}`;
+  if (!json.path || !fs.existsSync(json.path)) return `its launcher ${json.path || '(none)'} is missing`;
+  const node = (/"([^"]+node(?:\.exe)?)"/i.exec(fs.readFileSync(json.path, 'utf8')) || [])[1];
+  if (node && !fs.existsSync(node)) return `its launcher starts ${node}, which is gone (Node.js moved?)`;
+  const ext = readJson(path.join(dest, 'extension', 'manifest.json'));
+  const origin = ext && ext.key ? `chrome-extension://${installer.extensionId(ext)}/` : null;
+  if (origin && !(json.allowed_origins || []).includes(origin)) return 'it does not allow the Backdraw extension';
+  return null;
+}
+
+// c: install.js context. call: the bridge's call(method, params, timeout).
+async function gather(c, call) {
+  const p = c.platform;
+  const dest = p.installDir(c.home);
+  const pkg = readJson(path.join(dest, 'package.json'));
+  const ext = readJson(path.join(dest, 'extension', 'manifest.json'));
+  const exists = fs.existsSync(dest);
+  const facts = {
+    node: process.version, self: { version: SELF }, hostName: identity.HOST_NAME,
+    install: {
+      dir: dest, exists, missing: exists ? REQUIRED.filter(f => !fs.existsSync(path.join(dest, f))) : [],
+      version: pkg && pkg.version, extensionVersion: ext && ext.version,
+    },
+  };
+
+  const manifestFile = path.join(dest, `${identity.HOST_NAME}.json`);
+  const manifestThere = fs.existsSync(manifestFile);
+  facts.hostManifest = { file: manifestFile, exists: manifestThere, problem: manifestThere ? manifestProblem(readJson(manifestFile), dest) : null };
+
+  let reg = null;
+  try { reg = p.parseBrowserRegistry(p.readBrowserRegistry(identity.HOST_NAME)); } catch (e) { facts.registryError = e.message.split('\n')[0]; }
+  const targets = installer.targetBrowsers(p); // Chrome, and every other browser that is installed
+  facts.browsers = browsers.BROWSERS.map(b => ({
+    id: b.id, name: b.name, target: targets.includes(b.id),
+    registration: reg ? browsers.effectiveHost(b, reg.hosts) : null, policies: reg ? reg.policies[b.id] : null,
+  }));
+
+  try {
+    facts.bridge = { ok: true, status: await call('status', {}, 5000) };
+  } catch (e) {
+    facts.bridge = { ok: false, code: e.code, error: e.message };
+  }
+  if (facts.bridge.ok && facts.bridge.status.extension) {
+    try { facts.chatgpt = await call('chatgpt_state', {}, 15000); } catch (e) {
+      facts.chatgpt = { error: e.code === 'BAD_REQUEST' ? 'the running host is older than this version' : e.message };
+    }
+  }
+
+  const server = path.join(dest, 'mcp-server.js');
+  const problem = entry => (entry ? mcpClients.entryProblem(entry, server, cmd => commandExists(p, cmd)) : null);
+  const claudeFile = p.claudeConfigFile(c.home);
+  const claudeEntry = ((readJson(claudeFile) || {}).mcpServers || {})[identity.MCP_NAME] || null;
+  facts.clients = [{
+    id: 'claude-code', label: 'Claude Code', detected: !!c.claudeCli || fs.existsSync(claudeFile), entry: claudeEntry, problem: problem(claudeEntry),
+  }];
+  for (const client of mcpClients.FILE_CLIENTS) {
+    const fact = { id: client.id, label: client.label, detected: client.detect(c.clientEnv) };
+    try {
+      fact.entry = mcpClients.readEntry(client, c.clientEnv).entry;
+      fact.problem = problem(fact.entry);
+    } catch (e) { fact.error = e.message; }
+    facts.clients.push(fact);
+  }
+
+  const desktopFiles = p.desktopConfigFiles();
+  facts.desktop = {
+    files: desktopFiles.map(file => {
+      const json = readJson(file);
+      if (!json) return { file, error: `${file} is not valid JSON` };
+      const entry = (json.mcpServers || {})[identity.MCP_NAME] || null;
+      return { file, entry, problem: problem(entry) };
+    }),
+    running: desktopFiles.length ? p.desktopAppRunning() : false,
+  };
+  return facts;
+}
+
+// Repairs what `--fix` may: returns { fixed: [...], failed: [...] } lines.
+function fix(c, facts) {
+  const fixed = [];
+  const failed = [];
+  const dest = facts.install.dir;
+  if (!facts.install.exists || facts.install.missing.length) {
+    return { fixed, failed: [`The install folder is incomplete; run: ${report.SETUP}`] };
+  }
+  const server = path.join(dest, 'mcp-server.js');
+  // The manifest can be rewritten even when the registry couldn't be read; registering again
+  // doesn't need that read either.
+  const manifestBad = !facts.hostManifest.exists || !!facts.hostManifest.problem;
+  const registryBad = !facts.registryError && facts.browsers.some(b => b.target && (!b.registration
+    || path.resolve(b.registration.path).toLowerCase() !== path.resolve(facts.hostManifest.file).toLowerCase()));
+  if (manifestBad || registryBad) {
+    try {
+      const r = installer.registerHost(c, dest);
+      fixed.push(`Rewrote the host manifest and registered it for ${r.browsers.map(b => browsers.byId(b).name).join(', ')}.`);
+    } catch (e) { failed.push(`Couldn't register the native host: ${e.message}`); }
+  }
+  for (const client of facts.clients.filter(x => x.entry && x.problem)) {
+    try {
+      if (client.id === 'claude-code') installer.registerMcp(c, server);
+      else mcpClients.addEntry(mcpClients.byId(client.id), c.clientEnv, installer.NODE, server);
+      fixed.push(`${client.label}: the Backdraw entry now starts ${server}.`);
+    } catch (e) { failed.push(`${client.label}: ${e.message}`); }
+  }
+  for (const file of facts.desktop.files.filter(x => x.entry && x.problem)) {
+    if (facts.desktop.running !== false) { failed.push('Claude desktop app: it is running; quit it completely (also from the system tray) and run this again.'); continue; }
+    try {
+      installer.updateDesktopConfig(file.file, installer.desktopEntry(server));
+      fixed.push(`Claude desktop app: updated ${file.file} (a backup was made).`);
+    } catch (e) { failed.push(`Claude desktop app: ${e.message}`); }
+  }
+  return { fixed, failed };
+}
+
+// The tag in the pipe's name (the Windows user name), masked like the home folder.
+function userTag(p) {
+  try { return (/backdraw-(.+)$/.exec(p.pipePath()) || [])[1] || null; } catch { return null; }
+}
+
+async function doctor(opts = {}, deps = {}) {
+  const log = deps.log || (text => console.log(text));
+  const color = deps.color !== undefined ? deps.color : useColor();
+  const c = installer.context({ ...(deps.ctx || {}), report: false });
+  const call = deps.call || require('./shared').call;
+  const hide = text => report.mask(text, c.home, userTag(c.platform));
+  let facts = await gather(c, call);
+  if (opts.fix) {
+    const { fixed, failed } = fix(c, facts);
+    const paint = painter(color);
+    if (!fixed.length && !failed.length) log('Nothing to fix.');
+    for (const l of fixed) log(hide(line(paint, 'ok', 'Fixed:', l)));
+    for (const l of failed) log(hide(line(paint, 'fail', 'Not fixed:', l)));
+    log('');
+    facts = await gather(c, call);
+  }
+  const checks = report.evaluate(facts);
+  const header = `Backdraw doctor ${SELF} · Node ${process.version} · ${os.type()} ${os.release()}`;
+  log(hide(report.format(checks, { header, color })));
+  return checks;
+}
+
+module.exports = { REQUIRED, gather, fix, doctor };

package/extension/_locales/en/messages.json

@@ -0,0 +1,3 @@
+{
+  "extDescription": { "message": "Lets Claude generate images with your own signed-in ChatGPT account in a background tab. Runs entirely on your computer.", "description": "Extension description (manifest). Every other text is in i18n.js." }
+}

package/extension/_locales/tr/messages.json

@@ -0,0 +1,3 @@
+{
+  "extDescription": { "message": "Claude'un, oturum açtığın kendi ChatGPT hesabınla arka planda bir sekmede görsel üretmesini sağlar. Tamamen bilgisayarında çalışır.", "description": "Extension description (manifest). Every other text is in i18n.js." }
+}

package/extension/aspect.js

@@ -0,0 +1,25 @@
+// Centre-crop maths, shared by the service worker (importScripts: self.BackdrawAspect) and the
+// Node tests (require). Pure and dependency-free, so loading it first in background.js can't fail.
+(() => {
+  const TOLERANCE = 0.01; // lib/aspect.js TOLERANCE
+
+  // The largest rectangle of w:h centred in a width x height image ({x, y, width, height}, whole
+  // pixels): the limiting side is kept whole and the other is rounded to the nearest pixel. null
+  // when the image is already within tolerance of w:h, or too small to come any closer to it.
+  function cropRect(width, height, w, h, tolerance = TOLERANCE) {
+    if (!(width > 0 && height > 0 && w > 0 && h > 0)) return null;
+    // |(width/height) / (w/h) - 1| <= tolerance, cross-multiplied so exactly 1% off still counts.
+    if (Math.abs(width * h - height * w) <= tolerance * height * w) return null;
+    // Not whole multiples of the reduced ratio: with terms up to 100 those can cut dozens of pixels
+    // more than needed, from the side that should stay whole too, and beyond the band ChatGPT was told.
+    const wide = width * h > height * w;
+    const cw = wide ? Math.round((height * w) / h) : width;
+    const ch = wide ? height : Math.round((width * h) / w);
+    if (cw < 1 || ch < 1 || (cw === width && ch === height)) return null;
+    return { x: Math.floor((width - cw) / 2), y: Math.floor((height - ch) / 2), width: cw, height: ch };
+  }
+
+  const api = { TOLERANCE, cropRect };
+  if (typeof module === 'object' && module.exports) module.exports = api;
+  else self.BackdrawAspect = api;
+})();