@flarecode/import-memory 0.1.0 → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flarecode/import-memory",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "One-command helper for discovering local coding-agent memory sources before importing them into FlareCode.",
   "type": "module",
   "license": "UNLICENSED",

package/src/index.js

@@ -1,8 +1,64 @@
 #!/usr/bin/env node
+import { exec } from "node:child_process";
 import process from "node:process";
-import { formatScanSummary, parseSince, parseSourceFilter, scanSources } from "./scanner.js";
+import { formatScanSummary, parseSince, parseSourceFilter, readRulesContent, scanSources } from "./scanner.js";
 
-const VERSION = "0.1.0";
+const VERSION = "0.2.0";
+const API_BASE = "https://api.flarecode.sh";
+const APP_BASE = "https://app.flarecode.sh";
+
+async function startDeviceAuth() {
+  const res = await fetch(`${API_BASE}/cli/device/start`, { method: "POST" });
+  if (!res.ok) throw new Error(`Device auth failed: ${res.status}`);
+  return res.json();
+}
+
+async function pollDeviceToken(deviceCode, timeoutMs = 10 * 60 * 1000) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    await new Promise((r) => setTimeout(r, 2000));
+    const res = await fetch(`${API_BASE}/cli/device/poll?device_code=${deviceCode}`);
+    if (!res.ok) throw new Error(`Poll failed: ${res.status}`);
+    const data = await res.json();
+    if (data.status === "confirmed") return data.token;
+  }
+  throw new Error("Timed out waiting for browser confirmation (10 min).");
+}
+
+function openBrowser(url) {
+  const cmd =
+    process.platform === "darwin"
+      ? `open "${url}"`
+      : process.platform === "win32"
+        ? `start "" "${url}"`
+        : `xdg-open "${url}"`;
+  exec(cmd, () => {});
+}
+
+async function uploadImport(token, scanResult, rulesContent) {
+  const createRes = await fetch(`${API_BASE}/memory-imports`, {
+    method: "POST",
+    headers: { "content-type": "application/json", authorization: `Bearer ${token}` },
+    body: JSON.stringify({ platform: scanResult.platform }),
+  });
+  if (!createRes.ok) throw new Error(`Create import failed: ${createRes.status}`);
+  const { id: importId } = await createRes.json();
+
+  const chunksRes = await fetch(`${API_BASE}/memory-imports/${importId}/chunks`, {
+    method: "POST",
+    headers: { "content-type": "application/json", authorization: `Bearer ${token}` },
+    body: JSON.stringify({ sourcesJson: JSON.stringify(rulesContent) }),
+  });
+  if (!chunksRes.ok) throw new Error(`Upload chunks failed: ${chunksRes.status}`);
+
+  const completeRes = await fetch(`${API_BASE}/memory-imports/${importId}/complete`, {
+    method: "POST",
+    headers: { "content-type": "application/json", authorization: `Bearer ${token}` },
+  });
+  if (!completeRes.ok) throw new Error(`Complete failed: ${completeRes.status}`);
+
+  return importId;
+}
 
 async function main(argv) {
   const args = parseArgs(argv);
@@ -39,21 +95,34 @@ async function main(argv) {
   process.stdout.write(`${formatScanSummary(result)}\n`);
   process.stdout.write("\n");
 
-  if (args.dryRun) {
+  if (args.dryRun || args.skipUpload) {
     process.stdout.write("Dry run complete. Nothing was uploaded.\n");
     return;
   }
 
-  process.stdout.write("Next step: upload/linking is intentionally not in the shell wrapper.\n");
-  process.stdout.write(
-    "When the FlareCode import API is enabled, this same npm package will prompt you to link your account and upload reviewed summaries.\n",
-  );
-  process.stdout.write("For now, use --dry-run or --json to inspect what the helper can discover.\n");
+  try {
+    process.stdout.write("Starting secure browser auth...\n");
+    const { deviceCode, confirmUrl } = await startDeviceAuth();
+    process.stdout.write(`Opening: ${confirmUrl}\n`);
+    process.stdout.write(`If your browser doesn't open automatically, visit: ${confirmUrl}\n`);
+    openBrowser(confirmUrl);
+    process.stdout.write("Waiting for you to confirm in the browser...\n");
+    const token = await pollDeviceToken(deviceCode);
+    process.stdout.write("Authorized! Uploading scan summary...\n");
+    const rulesContent = await readRulesContent(result);
+    const importId = await uploadImport(token, result, rulesContent);
+    process.stdout.write(`Done. Review and approve your memory at: ${APP_BASE}/?memory=true\n`);
+    void importId;
+  } catch (err) {
+    process.stderr.write(`Upload failed: ${err instanceof Error ? err.message : String(err)}\n`);
+    process.exitCode = 1;
+  }
 }
 
 function parseArgs(argv) {
   const out = {
     dryRun: false,
+    skipUpload: false,
     json: false,
     help: false,
     version: false,
@@ -66,6 +135,7 @@ function parseArgs(argv) {
   for (let i = 0; i < argv.length; i += 1) {
     const arg = argv[i];
     if (arg === "--dry-run") out.dryRun = true;
+    else if (arg === "--skip-upload") out.skipUpload = true;
     else if (arg === "--json") out.json = true;
     else if (arg === "--help" || arg === "-h") out.help = true;
     else if (arg === "--version" || arg === "-v") out.version = true;
@@ -96,6 +166,7 @@ Usage:
 
 Options:
   --dry-run              Scan and print a summary without preparing upload.
+  --skip-upload          Scan and print a summary without uploading.
   --json                 Print machine-readable scan output.
   --source <list>        Comma-separated: claude,codex,cursor,vscode,repo.
   --since <duration>     Only include files modified within 30d, 12w, 6m, or 1y.

package/src/scanner.js

@@ -1,4 +1,4 @@
-import { access, readdir, stat } from "node:fs/promises";
+import { access, readFile, readdir, stat } from "node:fs/promises";
 import { homedir, platform } from "node:os";
 import path from "node:path";
 
@@ -166,6 +166,91 @@ export function formatScanSummary(result) {
   return lines.join("\n");
 }
 
+export async function readRulesContent(scanResult) {
+  const out = { rulesContent: [], settingsSummary: [] };
+  const REDACT_PATTERNS = [
+    /sk-[a-zA-Z0-9]{20,}/g,
+    /npm_[a-zA-Z0-9]{20,}/g,
+    /ghp_[a-zA-Z0-9]{20,}/g,
+    /AIza[0-9A-Za-z-_]{35}/g,
+    /Bearer\s+[a-zA-Z0-9._-]{20,}/gi,
+    /token["\s:=]+["']?[a-zA-Z0-9._-]{20,}/gi,
+    /secret["\s:=]+["']?[a-zA-Z0-9._-]{20,}/gi,
+    /password["\s:=]+["']?\S+/gi,
+    /apikey["\s:=]+["']?\S+/gi,
+  ];
+
+  const redact = (text) => {
+    let redacted = text;
+    for (const pat of REDACT_PATTERNS) redacted = redacted.replace(pat, "[REDACTED]");
+    return redacted;
+  };
+
+  for (const source of scanResult.sources) {
+    for (const file of source.files) {
+      if (file.kind !== "rule" && file.kind !== "settings") continue;
+      if (file.bytes > 100_000) continue;
+      try {
+        const raw = await readFile(file.path, "utf8");
+        const content = redact(raw).slice(0, 8000);
+        if (file.kind === "rule") {
+          out.rulesContent.push({ source: source.id, path: file.path, content });
+        } else {
+          const summary = extractSettingsSummary(raw, source.id);
+          if (summary) out.settingsSummary.push({ source: source.id, content: summary });
+        }
+      } catch {
+        // Unreadable files are skipped silently
+      }
+    }
+  }
+  return out;
+}
+
+function extractSettingsSummary(raw, sourceId) {
+  if (sourceId === "claude") {
+    try {
+      const data = JSON.parse(raw);
+      const lines = [];
+      if (data.defaultModel) lines.push(`Default model: ${data.defaultModel}`);
+      if (data.theme) lines.push(`Theme: ${data.theme}`);
+      if (Array.isArray(data.enabledModels)) lines.push(`Enabled models: ${data.enabledModels.join(", ")}`);
+      return lines.length ? lines.join("\n") : null;
+    } catch {
+      return null;
+    }
+  }
+  if (sourceId === "codex") {
+    const lines = raw.split("\n").filter((l) => {
+      const lower = l.toLowerCase();
+      return !lower.includes("token") && !lower.includes("key") && !lower.includes("secret") && l.trim().length > 0;
+    });
+    return lines.slice(0, 20).join("\n") || null;
+  }
+  if (sourceId === "cursor" || sourceId === "vscode") {
+    try {
+      const data = JSON.parse(raw);
+      const interested = [
+        "editor.fontSize",
+        "editor.tabSize",
+        "editor.formatOnSave",
+        "files.autoSave",
+        "workbench.colorTheme",
+        "editor.wordWrap",
+        "editor.defaultFormatter",
+      ];
+      const lines = [];
+      for (const key of interested) {
+        if (data[key] !== undefined) lines.push(`${key}: ${data[key]}`);
+      }
+      return lines.length ? lines.join("\n") : null;
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+
 async function scanSource(input) {
   const roots = [];
   const files = [];