replen 0.0.1 → 0.1.1

package/README.md

@@ -1,9 +1,53 @@
 # replen
 
-Placeholder for the [replen](https://replen.dev) toolkit. The actual functionality ships under the scoped packages:
+**Smart AI Development workflows.** One-command setup for [replen](https://replen.dev) — the AI that asks *"can we do this better?"* on your codebase, every morning.
 
-- `@replen/mcp` — MCP server for Claude Code / Codex
-- `@replen/cli` — command-line install / setup helper
-- (more to follow)
+```bash
+npx replen
+```
 
-Watch [the GitHub org](https://github.com/replen) (pending) or [replen.dev](https://replen.dev) for the launch.
+While your AI coding tool waits for prompts, replen reads your code against the ecosystem and surfaces drop-in libraries, ideas to port, and patterns to learn from. A proactive layer for your AI coding workflow.
+
+The single command above:
+1. Opens your browser to sign in / sign up at `app.replen.dev`
+2. Captures the auth back into the terminal (browser-callback flow, like `gh auth login`)
+3. Wires the [@replen/mcp](https://www.npmjs.com/package/@replen/mcp) server into your Claude Code / Codex config
+
+Same flow that `claude` itself uses for auth.
+
+## Subcommands
+
+```bash
+npx replen              # sign in + setup
+npx replen status       # show current config
+npx replen mcp setup    # re-wire MCP using saved auth
+npx replen logout       # forget saved auth (token stays valid; rotate on /settings to revoke)
+```
+
+## Self-host
+
+Pointing at your own replen instance:
+
+```bash
+REPLEN_BASE=https://replen.mydomain.dev npx replen
+```
+
+## How the auth works
+
+1. CLI generates a random state token and picks a free port (~38xxx)
+2. Starts a local HTTP server on `127.0.0.1:<port>/callback`
+3. Opens your browser to `https://app.replen.dev/cli-auth?port=<port>&state=<state>`
+4. You sign in (Firebase Auth) and click "Authorize CLI on this computer"
+5. Your browser navigates to `http://127.0.0.1:<port>/callback?token=<ing_...>&state=<state>`
+6. CLI validates state, saves the token to `~/.replen/config.json` (mode 0600)
+7. CLI continues and writes the MCP config into `~/.claude.json`
+
+The token never transits anything other than your browser ↔ localhost ↔ disk. The replen backend only sees it on subsequent MCP / API requests.
+
+## Revoke
+
+Rotate the ingest token on the [/settings](https://app.replen.dev/settings) page. The old one stops working immediately. Then re-run `npx replen` to get a fresh one.
+
+## License
+
+MIT — see [LICENSE](./LICENSE).

package/dist/config.js

@@ -0,0 +1,25 @@
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join, dirname } from "node:path";
+const CONFIG_DIR = join(homedir(), ".replen");
+const CONFIG_FILE = join(CONFIG_DIR, "config.json");
+export async function readConfig() {
+    try {
+        const raw = await readFile(CONFIG_FILE, "utf8");
+        const parsed = JSON.parse(raw);
+        if (typeof parsed?.token === "string" && typeof parsed?.base === "string") {
+            return parsed;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function writeConfig(cfg) {
+    await mkdir(dirname(CONFIG_FILE), { recursive: true, mode: 0o700 });
+    await writeFile(CONFIG_FILE, JSON.stringify(cfg, null, 2) + "\n", { mode: 0o600 });
+}
+export function configPath() {
+    return CONFIG_FILE;
+}

package/dist/index.js

@@ -0,0 +1,85 @@
+#!/usr/bin/env node
+import { runInit } from "./init.js";
+import { setupMcp } from "./mcp-setup.js";
+import { readConfig, configPath } from "./config.js";
+const HELP = `replen — Smart AI Development workflows
+
+Usage:
+  npx replen              Sign up / sign in + wire MCP into Claude Code
+  npx replen status       Show current config
+  npx replen mcp setup    Re-wire MCP using saved auth
+  npx replen logout       Forget saved auth
+  npx replen --help       This help
+
+Env:
+  REPLEN_BASE             Override dashboard URL (default https://app.replen.dev)
+
+Learn more: https://replen.dev
+`;
+async function main() {
+    const argv = process.argv.slice(2);
+    const cmd = argv[0];
+    if (cmd === "--help" || cmd === "-h" || cmd === "help") {
+        console.log(HELP);
+        return;
+    }
+    if (cmd === "status") {
+        const cfg = await readConfig();
+        if (!cfg) {
+            console.log(`Not signed in. Run \`npx replen\` to set up.`);
+            process.exit(1);
+        }
+        console.log(`Signed in.`);
+        console.log(`  Dashboard: ${cfg.base}`);
+        console.log(`  Token:     ${cfg.token.slice(0, 8)}…${cfg.token.slice(-4)}`);
+        console.log(`  Saved:     ${cfg.savedAt}`);
+        console.log(`  Config:    ${configPath()}`);
+        return;
+    }
+    if (cmd === "mcp" && argv[1] === "setup") {
+        const cfg = await readConfig();
+        if (!cfg) {
+            console.error(`Not signed in. Run \`npx replen\` first.`);
+            process.exit(1);
+        }
+        await setupMcp(cfg.token, cfg.base);
+        console.log(`\nRestart Claude Code to pick up the change.`);
+        return;
+    }
+    if (cmd === "logout") {
+        const { unlink } = await import("node:fs/promises");
+        try {
+            await unlink(configPath());
+            console.log(`Forgot auth at ${configPath()}`);
+        }
+        catch (e) {
+            if (e?.code === "ENOENT") {
+                console.log(`No saved auth — nothing to forget.`);
+            }
+            else {
+                throw e;
+            }
+        }
+        console.log(`Note: this only clears local auth. The token is still valid until you rotate it on /settings.`);
+        return;
+    }
+    if (cmd === undefined) {
+        // Default: if already signed in, just rerun mcp setup. Otherwise, full flow.
+        const cfg = await readConfig();
+        if (cfg) {
+            console.log(`Already signed in to ${cfg.base}. Re-wiring MCP config…`);
+            await setupMcp(cfg.token, cfg.base);
+            console.log(`\nDone. Run \`npx replen status\` to inspect.`);
+            return;
+        }
+        await runInit();
+        return;
+    }
+    console.error(`Unknown command: ${cmd}\n`);
+    console.error(HELP);
+    process.exit(1);
+}
+main().catch((e) => {
+    console.error(`\n✗ ${e?.message ?? String(e)}`);
+    process.exit(1);
+});

package/dist/init.js

@@ -0,0 +1,114 @@
+import { createServer } from "node:http";
+import { randomBytes } from "node:crypto";
+import { spawn } from "node:child_process";
+import { platform } from "node:os";
+import { writeConfig, configPath } from "./config.js";
+import { setupMcp } from "./mcp-setup.js";
+// Default web app URL — override with REPLEN_BASE for self-host.
+const DEFAULT_BASE = process.env.REPLEN_BASE || "https://app.replen.dev";
+// Range for the local callback listener. Anything in 1024-65535 works.
+const PORT_MIN = 38000;
+const PORT_MAX = 39000;
+function pickPort() {
+    return PORT_MIN + Math.floor(Math.random() * (PORT_MAX - PORT_MIN));
+}
+function openBrowser(url) {
+    const cmd = platform() === "darwin" ? "open"
+        : platform() === "win32" ? "start"
+            : "xdg-open";
+    // Detach — we don't care about its exit.
+    const proc = spawn(cmd, [url], { stdio: "ignore", detached: true });
+    proc.on("error", () => {
+        // Fail silently — we print the URL anyway as fallback.
+    });
+    proc.unref();
+}
+function waitForCallback(port, expectedState) {
+    return new Promise((resolve, reject) => {
+        const server = createServer((req, res) => {
+            const url = new URL(req.url ?? "/", `http://127.0.0.1:${port}`);
+            if (url.pathname !== "/callback") {
+                res.writeHead(404, { "content-type": "text/plain" });
+                res.end("not found");
+                return;
+            }
+            const token = url.searchParams.get("token");
+            const state = url.searchParams.get("state");
+            const base = url.searchParams.get("base") ?? DEFAULT_BASE;
+            if (!token || !state) {
+                res.writeHead(400, { "content-type": "text/plain" });
+                res.end("missing token/state");
+                return;
+            }
+            if (state !== expectedState) {
+                res.writeHead(400, { "content-type": "text/plain" });
+                res.end("state mismatch");
+                return;
+            }
+            res.writeHead(200, { "content-type": "text/html; charset=utf-8" });
+            res.end(SUCCESS_HTML);
+            // Give the response a tick to flush before we shut down the listener.
+            setTimeout(() => server.close(), 100);
+            resolve({ token, base });
+        });
+        server.on("error", reject);
+        server.listen(port, "127.0.0.1");
+        // 5-minute timeout. Browser closed, user wandered off, etc.
+        const timeout = setTimeout(() => {
+            server.close();
+            reject(new Error("Timed out waiting for browser callback (5 min)."));
+        }, 5 * 60 * 1000);
+        server.on("close", () => clearTimeout(timeout));
+    });
+}
+const SUCCESS_HTML = `<!doctype html>
+<html><head><meta charset="utf-8"><title>replen — authorized</title>
+<style>
+  body { font: 15px system-ui, -apple-system, sans-serif; max-width: 480px;
+         margin: 80px auto; padding: 0 24px; color: #111; line-height: 1.55; }
+  h1 { font-size: 22px; margin: 0 0 8px; }
+  p { color: #555; margin: 8px 0; }
+  .ok { color: #16a34a; font-weight: 600; }
+</style></head>
+<body>
+  <h1><span class="ok">✓</span> Authorized</h1>
+  <p>The replen CLI is now connected to your account.</p>
+  <p>You can close this tab and head back to your terminal — the CLI is finishing setup.</p>
+</body></html>`;
+export async function runInit() {
+    const state = randomBytes(32).toString("hex");
+    const port = pickPort();
+    const base = DEFAULT_BASE;
+    const authUrl = `${base}/cli-auth?port=${port}&state=${state}`;
+    console.log("");
+    console.log("  Opening your browser to sign in to replen…");
+    console.log("");
+    console.log(`  If it doesn't open automatically, visit:`);
+    console.log(`    ${authUrl}`);
+    console.log("");
+    console.log("  (Waiting for browser callback on http://127.0.0.1:" + port + "…)");
+    console.log("");
+    openBrowser(authUrl);
+    let result;
+    try {
+        result = await waitForCallback(port, state);
+    }
+    catch (e) {
+        console.error("  ✗ " + (e?.message ?? String(e)));
+        process.exit(1);
+    }
+    await writeConfig({
+        token: result.token,
+        base: result.base,
+        savedAt: new Date().toISOString(),
+    });
+    console.log(`  ✓ Saved auth to ${configPath()}`);
+    await setupMcp(result.token, result.base);
+    console.log("");
+    console.log("  All set. Restart Claude Code (or Codex) and try:");
+    console.log("    /replen-triage      — runs the morning triage protocol");
+    console.log("    use replen to digest_today — pulls today's matches");
+    console.log("");
+    console.log(`  Dashboard: ${result.base}`);
+    console.log("");
+}

package/dist/mcp-setup.js

@@ -0,0 +1,52 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync, renameSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, dirname } from "node:path";
+// Write the @replen/mcp server entry into Claude Code's config. Uses npx so
+// the user doesn't need a separate global install — Claude Code will fetch
+// @replen/mcp on first MCP launch and cache it.
+const SERVER_NAME = "replen";
+const CONFIG_PATH = join(homedir(), ".claude.json");
+function readJson(path) {
+    if (!existsSync(path))
+        return {};
+    const raw = readFileSync(path, "utf8");
+    if (!raw.trim())
+        return {};
+    return JSON.parse(raw);
+}
+function writeJsonAtomic(path, data) {
+    mkdirSync(dirname(path), { recursive: true });
+    const tmp = `${path}.tmp.${Date.now()}`;
+    writeFileSync(tmp, JSON.stringify(data, null, 2));
+    renameSync(tmp, path);
+}
+export async function setupMcp(token, base) {
+    console.log(`  Wiring replen MCP into Claude Code config…`);
+    if (existsSync(CONFIG_PATH)) {
+        const backup = `${CONFIG_PATH}.bak`;
+        writeFileSync(backup, readFileSync(CONFIG_PATH));
+        console.log(`  (backed up existing config to ${backup})`);
+    }
+    let config;
+    try {
+        config = readJson(CONFIG_PATH);
+    }
+    catch (e) {
+        console.error(`  ✗ ${CONFIG_PATH} is not valid JSON: ${e.message}`);
+        console.error(`    Fix the file manually and run \`replen mcp setup\`.`);
+        process.exit(1);
+    }
+    const mcpServers = config.mcpServers ?? {};
+    const overwrite = !!mcpServers[SERVER_NAME];
+    mcpServers[SERVER_NAME] = {
+        type: "stdio",
+        command: "npx",
+        args: ["-y", "@replen/mcp"],
+        env: {
+            DIGEST_BASE_URL: base,
+            DIGEST_TOKEN: token,
+        },
+    };
+    writeJsonAtomic(CONFIG_PATH, { ...config, mcpServers });
+    console.log(`  ✓ ${overwrite ? "Updated" : "Added"} "${SERVER_NAME}" in ${CONFIG_PATH}`);
+}

package/package.json

@@ -1,10 +1,36 @@
 {
   "name": "replen",
-  "version": "0.0.1",
-  "description": "Placeholder — the replen toolkit (MCP server, CLI, web dashboard) is being prepared for OSS release. Visit https://replen.dev when live.",
-  "keywords": ["placeholder", "oss-digest", "mcp", "claude-code", "codex"],
+  "version": "0.1.1",
+  "description": "Smart AI Development workflows. The AI that asks 'can we do this better?' — replen reads your codebase against the live ecosystem every morning, surfaces drop-in libraries, ideas to port, and patterns to learn from. A proactive layer for your AI coding workflow. One-command setup: opens a browser to sign in, then wires the MCP server into Claude Code / Codex.",
+  "type": "module",
+  "bin": {
+    "replen": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc && chmod +x dist/index.js",
+    "dev": "tsx src/index.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": ["replen", "oss-discovery", "claude-code", "mcp", "cli"],
   "homepage": "https://replen.dev",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/replenhq/replen.git",
+    "directory": "cli"
+  },
+  "bugs": "https://github.com/replenhq/replen/issues",
   "license": "MIT",
-  "main": "index.js",
-  "files": ["index.js", "README.md", "LICENSE"]
+  "engines": {
+    "node": ">=18"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.5",
+    "tsx": "^4.19.2",
+    "typescript": "^5.7.2"
+  }
 }

package/index.js

@@ -1,5 +0,0 @@
-#!/usr/bin/env node
-// Placeholder for the replen toolkit. The actual packages (CLI, MCP server)
-// will ship under the @replen scope.
-console.error("This is a placeholder. See https://replen.dev — actual packages: @replen/mcp, @replen/cli (coming soon).");
-process.exit(0);