@memfork/cli 0.1.0

package/dist/commands/ui-server.js

@@ -0,0 +1,217 @@
+/**
+ * `memfork ui` — local HTTP server.
+ *
+ * Serves the pre-built React app from app/dist/ as static files and
+ * exposes two API routes so the React app can discover the current tree
+ * config and recall MemWal facts without exposing credentials in the
+ * browser bundle.
+ *
+ *   GET /api/config   → { treeId, packageId, network, rpcUrl, hasMemwal }
+ *   GET /api/facts    → { facts: MemWal results[] }  (proxied server-side)
+ *   GET /*            → index.html (SPA fallback)
+ *   GET /assets/*     → static file
+ */
+import http from "node:http";
+import fs from "node:fs";
+import path from "node:path";
+import { readProjectConfig, readCredentials, MEMWAL_CONSTANTS } from "../config.js";
+const MIME = {
+    ".html": "text/html; charset=utf-8",
+    ".js": "application/javascript",
+    ".mjs": "application/javascript",
+    ".css": "text/css",
+    ".svg": "image/svg+xml",
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".ico": "image/x-icon",
+    ".json": "application/json",
+    ".woff": "font/woff",
+    ".woff2": "font/woff2",
+    ".map": "application/json",
+};
+function getMime(filePath) {
+    return MIME[path.extname(filePath).toLowerCase()] ?? "application/octet-stream";
+}
+function json(res, data, status = 200) {
+    const body = JSON.stringify(data);
+    res.writeHead(status, {
+        "Content-Type": "application/json",
+        "Access-Control-Allow-Origin": "*",
+        "Cache-Control": "no-store",
+    });
+    res.end(body);
+}
+async function handleApiConfig(res) {
+    const project = readProjectConfig();
+    const creds = readCredentials();
+    const treeId = project?.treeId ?? creds.default ?? null;
+    const network = (project?.network ?? "testnet");
+    const stored = treeId ? creds.trees[treeId] : undefined;
+    json(res, {
+        treeId,
+        packageId: project?.packageId ?? "0x7df9719d799386d34d657c49ae8cd6f5f03b39036f7c428b556095e42afd852f",
+        network,
+        rpcUrl: project?.rpcUrl ?? null,
+        hasMemwal: !!(stored?.memwalKey && stored?.memwalAccountId),
+    });
+}
+async function memwalSearch(relayer, key, accountId, namespace, limit = 200) {
+    const upstream = await fetch(`${relayer}/api/search`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            "Authorization": `Bearer ${key}`,
+            "x-memwal-account-id": accountId,
+        },
+        body: JSON.stringify({ query: "", namespace, limit }),
+        signal: AbortSignal.timeout(8_000),
+    });
+    if (!upstream.ok)
+        return [];
+    const data = await upstream.json();
+    return (data["results"] ?? data["entries"] ?? []);
+}
+async function handleApiFacts(res, url) {
+    const branch = url.searchParams.get("branch") ?? "main";
+    const project = readProjectConfig();
+    const creds = readCredentials();
+    const treeId = project?.treeId ?? creds.default;
+    const network = (project?.network ?? "testnet");
+    const stored = treeId ? creds.trees[treeId] : undefined;
+    if (!stored?.memwalKey || !stored?.memwalAccountId || !treeId) {
+        json(res, { facts: [] });
+        return;
+    }
+    const relayer = stored.memwalRelayer ?? MEMWAL_CONSTANTS[network].relayer;
+    const treeHex = treeId.startsWith("0x") ? treeId.slice(2) : treeId;
+    const namespace = `memforks/${treeHex}/${branch}`;
+    try {
+        const facts = await memwalSearch(relayer, stored.memwalKey, stored.memwalAccountId, namespace);
+        json(res, { facts });
+    }
+    catch (e) {
+        json(res, { facts: [], error: String(e) });
+    }
+}
+/**
+ * GET /api/history?branch=<name>&limit=<n>
+ *
+ * Returns all off-chain CommitPayload objects stored in MemWal for this branch,
+ * sorted oldest-first. Each entry includes the MemWal blob_id plus the parsed
+ * payload fields that the UI needs (branch, author, ts_ms, delta, parent_blob_ids).
+ *
+ * The browser cannot call MemWal directly (SEAL-encrypted, key lives server-side),
+ * so this endpoint acts as the commit-history proxy.
+ */
+async function handleApiHistory(res, url) {
+    const branch = url.searchParams.get("branch") ?? "main";
+    const limit = Math.min(Number(url.searchParams.get("limit") ?? "500"), 1000);
+    const project = readProjectConfig();
+    const creds = readCredentials();
+    const treeId = project?.treeId ?? creds.default;
+    const network = (project?.network ?? "testnet");
+    const stored = treeId ? creds.trees[treeId] : undefined;
+    if (!stored?.memwalKey || !stored?.memwalAccountId || !treeId) {
+        json(res, { commits: [] });
+        return;
+    }
+    const relayer = stored.memwalRelayer ?? MEMWAL_CONSTANTS[network].relayer;
+    const treeHexH = treeId.startsWith("0x") ? treeId.slice(2) : treeId;
+    const namespace = `memforks/${treeHexH}/${branch}`;
+    try {
+        const results = await memwalSearch(relayer, stored.memwalKey, stored.memwalAccountId, namespace, limit);
+        const commits = results.flatMap((entry) => {
+            const e = entry;
+            const blobId = String(e["blob_id"] ?? "");
+            const text = String(e["text"] ?? "");
+            // Try to parse the stored text as a CommitPayload JSON.
+            let payload = null;
+            try {
+                payload = JSON.parse(text);
+            }
+            catch {
+                return [];
+            }
+            if (payload["type"] !== "commit")
+                return [];
+            return [{
+                    blob_id: blobId,
+                    branch: String(payload["branch"] ?? branch),
+                    ts_ms: Number(payload["ts_ms"] ?? 0),
+                    parent_blob_ids: payload["parent_blob_ids"] ?? [],
+                    parent_blob_hashes: payload["parent_blob_hashes"] ?? [],
+                    // Extract readable facts from the delta.
+                    message: (() => {
+                        const delta = payload["delta"];
+                        const facts = delta?.["facts"];
+                        return facts?.length ? facts[0] : `commit ${blobId.slice(0, 8)}`;
+                    })(),
+                    delta: payload["delta"] ?? {},
+                }];
+        });
+        // Sort oldest-first by ts_ms.
+        commits.sort((a, b) => a.ts_ms - b.ts_ms);
+        json(res, { commits, branch });
+    }
+    catch (e) {
+        json(res, { commits: [], error: String(e) });
+    }
+}
+function serveStatic(res, distDir, urlPath) {
+    // Resolve the requested file path.
+    let filePath = path.join(distDir, urlPath);
+    // SPA fallback: no extension or file not found → serve index.html.
+    if (!path.extname(filePath) || !fs.existsSync(filePath)) {
+        filePath = path.join(distDir, "index.html");
+    }
+    if (!fs.existsSync(filePath)) {
+        res.writeHead(404, { "Content-Type": "text/plain" });
+        res.end("Not found");
+        return;
+    }
+    const mimeType = getMime(filePath);
+    const isImmutable = urlPath.startsWith("/assets/");
+    res.writeHead(200, {
+        "Content-Type": mimeType,
+        "Cache-Control": isImmutable
+            ? "public, max-age=31536000, immutable"
+            : "no-cache",
+        "Access-Control-Allow-Origin": "*",
+    });
+    fs.createReadStream(filePath).pipe(res);
+}
+export function startUiServer(distDir, port = 4242) {
+    const server = http.createServer((req, res) => {
+        const url = new URL(req.url ?? "/", `http://localhost:${port}`);
+        // CORS pre-flight.
+        if (req.method === "OPTIONS") {
+            res.writeHead(204, { "Access-Control-Allow-Origin": "*" });
+            res.end();
+            return;
+        }
+        if (url.pathname === "/api/config") {
+            handleApiConfig(res).catch((e) => json(res, { error: String(e) }, 500));
+            return;
+        }
+        if (url.pathname === "/api/facts") {
+            handleApiFacts(res, url).catch((e) => json(res, { facts: [], error: String(e) }, 500));
+            return;
+        }
+        if (url.pathname === "/api/history") {
+            handleApiHistory(res, url).catch((e) => json(res, { commits: [], error: String(e) }, 500));
+            return;
+        }
+        serveStatic(res, distDir, url.pathname);
+    });
+    server.listen(port, "127.0.0.1", () => {
+        console.log(`  http://localhost:${port}`);
+    });
+    server.on("error", (e) => {
+        if (e.code === "EADDRINUSE") {
+            console.error(`  Port ${port} is already in use. Is memfork ui already running?`);
+            process.exit(1);
+        }
+        throw e;
+    });
+    return server;
+}

package/dist/config.d.ts

@@ -0,0 +1,110 @@
+/**
+ * Layered config resolver.
+ *
+ * Layer 1 (lowest priority) — project-local, committable:
+ *   .memfork/config.json   { treeId, network, defaultBranch, rpcUrl, packageId }
+ *
+ * Layer 2 — user-global, secrets, never committed (chmod 600):
+ *   ~/.memfork/credentials.json
+ *   {
+ *     "default": "<treeId>",                     // which tree to use when none specified
+ *     "trees": {
+ *       "<treeId>": {
+ *         "privateKey": "suiprivkey1...",
+ *         "memwalAccountId": "0x...",
+ *         "memwalKey": "<64-char-hex>"
+ *       }
+ *     }
+ *   }
+ *
+ * Layer 3 (highest priority) — env var overrides for CI / headless use:
+ *   MEMFORK_TREE_ID, MEMFORK_PRIVATE_KEY, MEMFORK_MEMWAL_ACCOUNT, MEMFORK_MEMWAL_KEY
+ *
+ * Plugins and hooks call the CLI binary and never read credentials themselves.
+ */
+export declare const MEMWAL_CONSTANTS: {
+    readonly testnet: {
+        readonly packageId: "0xcf6ad755a1cdff7217865c796778fabe5aa399cb0cf2eba986f4b582047229c6";
+        readonly registryId: "0xe80f2feec1c139616a86c9f71210152e2a7ca552b20841f2e192f99f75864437";
+        readonly relayer: "https://relayer.staging.memwal.ai";
+    };
+    readonly mainnet: {
+        readonly packageId: "0xcee7a6fd8de52ce645c38332bde23d4a30fd9426bc4681409733dd50958a24c6";
+        readonly registryId: "0x0da982cefa26864ae834a8a0504b904233d49e20fcc17c373c8bed99c75a7edd";
+        readonly relayer: "https://relayer.memwal.ai";
+    };
+};
+export interface ProjectConfig {
+    /** Sui MemoryTree object ID. */
+    treeId?: string;
+    /** Sui network. Default: "testnet". */
+    network?: "testnet" | "mainnet" | "devnet" | "localnet";
+    /** Default branch name. Default: "main". */
+    defaultBranch?: string;
+    /** Override Sui RPC URL. */
+    rpcUrl?: string;
+    /** Override package ID (post-upgrade). */
+    packageId?: string;
+}
+export interface TreeCredential {
+    /** Ed25519 private key in bech32 suiprivkey1… format. */
+    privateKey: string;
+    /** MemWal account object ID. */
+    memwalAccountId: string;
+    /** MemWal delegate key (64-char hex). */
+    memwalKey: string;
+    /** Optional MemWal relayer URL override. */
+    memwalRelayer?: string;
+}
+export interface CredentialsFile {
+    /** treeId of the tree to use when no project config is present. */
+    default?: string;
+    trees: Record<string, TreeCredential>;
+}
+/** Fully resolved, ready-to-use config for a single tree. */
+export interface ResolvedConfig {
+    treeId: string;
+    privateKey: string;
+    memwalAccountId: string;
+    memwalKey: string;
+    memwalRelayer: string;
+    network: "testnet" | "mainnet" | "devnet" | "localnet";
+    defaultBranch: string;
+    rpcUrl?: string;
+    packageId?: string;
+}
+export declare function projectConfigPath(cwd?: string): string;
+export declare function credentialsPath(): string;
+export declare function readProjectConfig(cwd?: string): ProjectConfig | null;
+export declare function readCredentials(): CredentialsFile;
+export declare function writeProjectConfig(cfg: ProjectConfig, cwd?: string): void;
+export declare function writeCredentials(creds: CredentialsFile): void;
+export declare function upsertCredential(treeId: string, cred: TreeCredential): void;
+export declare function setDefaultTree(treeId: string): void;
+export declare class ConfigError extends Error {
+    constructor(message: string);
+}
+/**
+ * Resolve the full config for a single tree, merging all three layers.
+ * Throws `ConfigError` with a human-readable message if anything is missing.
+ */
+export declare function resolveConfig(opts?: {
+    treeId?: string;
+    cwd?: string;
+}): ResolvedConfig;
+/**
+ * Build a `MemForksClientConfig` from resolved config (for SDK calls).
+ * Imported by commands that need to create a MemForksClient.
+ */
+export declare function toClientConfig(r: ResolvedConfig): {
+    treeId: string;
+    signer: string;
+    network: "testnet" | "mainnet" | "devnet" | "localnet";
+    rpcUrl: string | undefined;
+    packageId: string | undefined;
+    memwal: {
+        accountId: string;
+        delegateKey: string;
+        serverUrl: string;
+    };
+};

package/dist/config.js

@@ -0,0 +1,200 @@
+/**
+ * Layered config resolver.
+ *
+ * Layer 1 (lowest priority) — project-local, committable:
+ *   .memfork/config.json   { treeId, network, defaultBranch, rpcUrl, packageId }
+ *
+ * Layer 2 — user-global, secrets, never committed (chmod 600):
+ *   ~/.memfork/credentials.json
+ *   {
+ *     "default": "<treeId>",                     // which tree to use when none specified
+ *     "trees": {
+ *       "<treeId>": {
+ *         "privateKey": "suiprivkey1...",
+ *         "memwalAccountId": "0x...",
+ *         "memwalKey": "<64-char-hex>"
+ *       }
+ *     }
+ *   }
+ *
+ * Layer 3 (highest priority) — env var overrides for CI / headless use:
+ *   MEMFORK_TREE_ID, MEMFORK_PRIVATE_KEY, MEMFORK_MEMWAL_ACCOUNT, MEMFORK_MEMWAL_KEY
+ *
+ * Plugins and hooks call the CLI binary and never read credentials themselves.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+// ─── Public network constants ─────────────────────────────────────────────────
+// Sources: https://docs.memwal.ai/contract/overview
+export const MEMWAL_CONSTANTS = {
+    testnet: {
+        packageId: "0xcf6ad755a1cdff7217865c796778fabe5aa399cb0cf2eba986f4b582047229c6",
+        registryId: "0xe80f2feec1c139616a86c9f71210152e2a7ca552b20841f2e192f99f75864437",
+        relayer: "https://relayer.staging.memwal.ai",
+    },
+    mainnet: {
+        packageId: "0xcee7a6fd8de52ce645c38332bde23d4a30fd9426bc4681409733dd50958a24c6",
+        registryId: "0x0da982cefa26864ae834a8a0504b904233d49e20fcc17c373c8bed99c75a7edd",
+        relayer: "https://relayer.memwal.ai",
+    },
+};
+// ─── Paths ────────────────────────────────────────────────────────────────────
+const DEFAULT_RELAYER = "https://relayer.staging.memwal.ai";
+export function projectConfigPath(cwd = process.cwd()) {
+    return path.join(cwd, ".memfork", "config.json");
+}
+/**
+ * Walk up the directory tree from `cwd` looking for a `.memfork/config.json`,
+ * just like git looks for `.git`. Returns the first one found, or null.
+ */
+function findProjectConfigPath(cwd = process.cwd()) {
+    let dir = cwd;
+    while (true) {
+        const candidate = path.join(dir, ".memfork", "config.json");
+        if (fs.existsSync(candidate))
+            return candidate;
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            return null; // reached filesystem root
+        dir = parent;
+    }
+}
+export function credentialsPath() {
+    return path.join(os.homedir(), ".memfork", "credentials.json");
+}
+// ─── Read helpers ─────────────────────────────────────────────────────────────
+export function readProjectConfig(cwd = process.cwd()) {
+    const p = findProjectConfigPath(cwd);
+    if (!p)
+        return null;
+    try {
+        return JSON.parse(fs.readFileSync(p, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+export function readCredentials() {
+    const p = credentialsPath();
+    if (!fs.existsSync(p))
+        return { trees: {} };
+    try {
+        return JSON.parse(fs.readFileSync(p, "utf8"));
+    }
+    catch {
+        return { trees: {} };
+    }
+}
+// ─── Write helpers ────────────────────────────────────────────────────────────
+export function writeProjectConfig(cfg, cwd = process.cwd()) {
+    const root = findGitRoot(cwd) ?? cwd;
+    const dir = path.join(root, ".memfork");
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(path.join(root, ".memfork", "config.json"), JSON.stringify(cfg, null, 2) + "\n", "utf8");
+}
+function findGitRoot(cwd) {
+    let dir = cwd;
+    while (true) {
+        if (fs.existsSync(path.join(dir, ".git")))
+            return dir;
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            return null;
+        dir = parent;
+    }
+}
+export function writeCredentials(creds) {
+    const dir = path.join(os.homedir(), ".memfork");
+    fs.mkdirSync(dir, { recursive: true });
+    const p = credentialsPath();
+    fs.writeFileSync(p, JSON.stringify(creds, null, 2) + "\n", "utf8");
+    // 600: owner read+write only — no other users can read private keys.
+    fs.chmodSync(p, 0o600);
+}
+export function upsertCredential(treeId, cred) {
+    const creds = readCredentials();
+    creds.trees[treeId] = cred;
+    if (!creds.default)
+        creds.default = treeId;
+    writeCredentials(creds);
+}
+export function setDefaultTree(treeId) {
+    const creds = readCredentials();
+    creds.default = treeId;
+    writeCredentials(creds);
+}
+// ─── Resolution ───────────────────────────────────────────────────────────────
+export class ConfigError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "ConfigError";
+    }
+}
+/**
+ * Resolve the full config for a single tree, merging all three layers.
+ * Throws `ConfigError` with a human-readable message if anything is missing.
+ */
+export function resolveConfig(opts = {}) {
+    const project = readProjectConfig(opts.cwd);
+    const creds = readCredentials();
+    const env = process.env;
+    // ── Resolve treeId ──────────────────────────────────────────────────────────
+    const treeId = env["MEMFORK_TREE_ID"] ??
+        opts.treeId ??
+        project?.treeId ??
+        creds.default;
+    if (!treeId) {
+        throw new ConfigError("No MemoryTree found. Run `memfork init` to create or link one.");
+    }
+    // ── Resolve credentials ────────────────────────────────────────────────────
+    const stored = creds.trees[treeId];
+    const privateKey = env["MEMFORK_PRIVATE_KEY"] ??
+        stored?.privateKey;
+    const memwalAccountId = env["MEMFORK_MEMWAL_ACCOUNT"] ??
+        stored?.memwalAccountId;
+    const memwalKey = env["MEMFORK_MEMWAL_KEY"] ??
+        stored?.memwalKey;
+    if (!privateKey) {
+        throw new ConfigError(`No private key for tree ${treeId}. Run \`memfork init\` or set MEMFORK_PRIVATE_KEY.`);
+    }
+    if (!memwalAccountId) {
+        throw new ConfigError(`No MemWal account for tree ${treeId}. Run \`memfork init\` or set MEMFORK_MEMWAL_ACCOUNT.`);
+    }
+    if (!memwalKey) {
+        throw new ConfigError(`No MemWal delegate key for tree ${treeId}. Run \`memfork init\` or set MEMFORK_MEMWAL_KEY.`);
+    }
+    // ── Merge non-secret config ────────────────────────────────────────────────
+    const network = (env["MEMFORK_NETWORK"] ??
+        project?.network ??
+        "mainnet");
+    return {
+        treeId,
+        privateKey,
+        memwalAccountId,
+        memwalKey,
+        memwalRelayer: stored?.memwalRelayer ?? DEFAULT_RELAYER,
+        network,
+        defaultBranch: project?.defaultBranch ?? "main",
+        rpcUrl: env["MEMFORK_RPC_URL"] ?? project?.rpcUrl,
+        packageId: env["MEMFORK_PACKAGE_ID"] ?? project?.packageId,
+    };
+}
+/**
+ * Build a `MemForksClientConfig` from resolved config (for SDK calls).
+ * Imported by commands that need to create a MemForksClient.
+ */
+export function toClientConfig(r) {
+    return {
+        treeId: r.treeId,
+        signer: r.privateKey,
+        network: r.network,
+        rpcUrl: r.rpcUrl,
+        packageId: r.packageId,
+        memwal: {
+            accountId: r.memwalAccountId,
+            delegateKey: r.memwalKey,
+            serverUrl: r.memwalRelayer,
+        },
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @memfork/cli — library exports
+ *
+ * Import the config API from here:
+ *   import { resolveConfig, toClientConfig } from "@memfork/cli"
+ *
+ * The CLI binary entry point is src/cli.ts → dist/cli.js
+ */
+export { resolveConfig, toClientConfig, readProjectConfig, writeProjectConfig, readCredentials, writeCredentials, upsertCredential, setDefaultTree, projectConfigPath, credentialsPath, ConfigError, } from "./config.js";

package/dist/index.js

@@ -0,0 +1,9 @@
+/**
+ * @memfork/cli — library exports
+ *
+ * Import the config API from here:
+ *   import { resolveConfig, toClientConfig } from "@memfork/cli"
+ *
+ * The CLI binary entry point is src/cli.ts → dist/cli.js
+ */
+export { resolveConfig, toClientConfig, readProjectConfig, writeProjectConfig, readCredentials, writeCredentials, upsertCredential, setDefaultTree, projectConfigPath, credentialsPath, ConfigError, } from "./config.js";

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@memfork/cli",
+  "version": "0.1.0",
+  "description": "MemForks CLI — init, commit, recall, merge, install plugins",
+  "type": "module",
+  "bin": {
+    "memfork": "dist/cli.js"
+  },
+  "main": "./dist/index.js",
+  "exports": {
+    ".": "./dist/index.js",
+    "./config": "./dist/config.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "start": "node dist/index.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@inquirer/prompts": "^8.5.2",
+    "@memfork/core": "^0.1.0",
+    "chalk": "^5.6.2",
+    "commander": "^15.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.4.0"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "license": "Apache-2.0"
+}