@iamem/amem 0.1.0

package/dist/service.js

@@ -0,0 +1,254 @@
+import { existsSync, mkdirSync, unlinkSync, writeFileSync, chmodSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { execFileSync } from "node:child_process";
+import { amemHome } from "./paths.js";
+import { resolveAmemProgramArgs } from "./install/skills.js";
+export const SERVICE_LABEL = "co.amem.ui";
+export const SYSTEMD_UNIT = "amem-ui.service";
+export function servicePlatform() {
+    if (process.platform === "darwin")
+        return "darwin";
+    if (process.platform === "linux")
+        return "linux";
+    if (process.platform === "win32")
+        return "win32";
+    return "unsupported";
+}
+export function isServiceSupported() {
+    return servicePlatform() !== "unsupported";
+}
+export function launchAgentPath() {
+    return join(homedir(), "Library", "LaunchAgents", `${SERVICE_LABEL}.plist`);
+}
+export function systemdUserUnitPath() {
+    return join(homedir(), ".config", "systemd", "user", SYSTEMD_UNIT);
+}
+export function windowsStartupCmdPath() {
+    const appData = process.env.APPDATA || join(homedir(), "AppData", "Roaming");
+    return join(appData, "Microsoft", "Windows", "Start Menu", "Programs", "Startup", "amem-ui.cmd");
+}
+export function serviceInstallPath() {
+    const p = servicePlatform();
+    if (p === "darwin")
+        return launchAgentPath();
+    if (p === "linux")
+        return systemdUserUnitPath();
+    if (p === "win32")
+        return windowsStartupCmdPath();
+    return "";
+}
+export function isServiceInstalled() {
+    const path = serviceInstallPath();
+    return Boolean(path && existsSync(path));
+}
+function escapeXml(value) {
+    return value
+        .replace(/&/g, "&")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;");
+}
+function programCommandLine() {
+    const args = resolveAmemProgramArgs("ui", "--no-open");
+    const shellLine = args.map((a) => (/\s/.test(a) ? `"${a.replace(/"/g, '\\"')}"` : a)).join(" ");
+    return { args, shellLine };
+}
+function plistBody() {
+    const { args } = programCommandLine();
+    const argXml = args.map((a) => `    <string>${escapeXml(a)}</string>`).join("\n");
+    const logs = amemHome();
+    const pathEnv = ["/opt/homebrew/bin", "/usr/local/bin", "/usr/bin", "/bin"].join(":");
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${SERVICE_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+${argXml}
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <dict>
+    <key>SuccessfulExit</key>
+    <false/>
+  </dict>
+  <key>WorkingDirectory</key>
+  <string>${escapeXml(homedir())}</string>
+  <key>StandardOutPath</key>
+  <string>${escapeXml(join(logs, "ui.log"))}</string>
+  <key>StandardErrorPath</key>
+  <string>${escapeXml(join(logs, "ui.err.log"))}</string>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>PATH</key>
+    <string>${escapeXml(pathEnv)}</string>
+  </dict>
+</dict>
+</plist>
+`;
+}
+function systemdUnitBody() {
+    const { shellLine } = programCommandLine();
+    const logs = amemHome();
+    return `[Unit]
+Description=amem local UI (loopback only)
+After=default.target
+
+[Service]
+Type=simple
+ExecStart=${shellLine}
+WorkingDirectory=${homedir()}
+Restart=on-failure
+RestartSec=3
+StandardOutput=append:${join(logs, "ui.log")}
+StandardError=append:${join(logs, "ui.err.log")}
+Environment=PATH=/usr/local/bin:/usr/bin:/bin:${homedir()}/.local/bin
+
+[Install]
+WantedBy=default.target
+`;
+}
+function windowsCmdBody() {
+    const { shellLine } = programCommandLine();
+    return `@echo off\r\nrem amem local UI (Generated by amem)\r\nstart "" /B ${shellLine}\r\n`;
+}
+function uid() {
+    return String(process.getuid?.() ?? "");
+}
+function launchctl(args) {
+    execFileSync("launchctl", args, { stdio: ["ignore", "pipe", "pipe"] });
+}
+function systemctlUser(args) {
+    execFileSync("systemctl", ["--user", ...args], { stdio: ["ignore", "pipe", "pipe"] });
+}
+function installDarwin() {
+    const path = launchAgentPath();
+    mkdirSync(join(homedir(), "Library", "LaunchAgents"), { recursive: true });
+    writeFileSync(path, plistBody(), "utf8");
+    const domain = `gui/${uid()}`;
+    try {
+        launchctl(["bootout", domain, path]);
+    }
+    catch {
+        // not loaded yet
+    }
+    try {
+        launchctl(["bootstrap", domain, path]);
+    }
+    catch {
+        try {
+            launchctl(["load", "-w", path]);
+        }
+        catch {
+            // plist is on disk; next login still picks it up
+        }
+    }
+    return { path, installed: true };
+}
+function uninstallDarwin() {
+    const path = launchAgentPath();
+    if (existsSync(path)) {
+        try {
+            launchctl(["bootout", `gui/${uid()}`, path]);
+        }
+        catch {
+            try {
+                launchctl(["unload", "-w", path]);
+            }
+            catch {
+                // ignore
+            }
+        }
+        unlinkSync(path);
+    }
+    return { path, installed: false };
+}
+function installLinux() {
+    const path = systemdUserUnitPath();
+    mkdirSync(join(homedir(), ".config", "systemd", "user"), { recursive: true });
+    mkdirSync(amemHome(), { recursive: true });
+    writeFileSync(path, systemdUnitBody(), "utf8");
+    try {
+        systemctlUser(["daemon-reload"]);
+    }
+    catch {
+        // unit file still valid for next login / manual start
+    }
+    try {
+        systemctlUser(["enable", "--now", SYSTEMD_UNIT]);
+    }
+    catch {
+        try {
+            systemctlUser(["enable", SYSTEMD_UNIT]);
+        }
+        catch {
+            // enabled-at-login may require lingering; file is installed
+        }
+    }
+    return { path, installed: true };
+}
+function uninstallLinux() {
+    const path = systemdUserUnitPath();
+    try {
+        systemctlUser(["disable", "--now", SYSTEMD_UNIT]);
+    }
+    catch {
+        try {
+            systemctlUser(["disable", SYSTEMD_UNIT]);
+        }
+        catch {
+            // ignore
+        }
+    }
+    if (existsSync(path))
+        unlinkSync(path);
+    try {
+        systemctlUser(["daemon-reload"]);
+    }
+    catch {
+        // ignore
+    }
+    return { path, installed: false };
+}
+function installWindows() {
+    const path = windowsStartupCmdPath();
+    mkdirSync(join(path, ".."), { recursive: true });
+    writeFileSync(path, windowsCmdBody(), "utf8");
+    try {
+        chmodSync(path, 0o644);
+    }
+    catch {
+        // windows may ignore mode
+    }
+    return { path, installed: true };
+}
+function uninstallWindows() {
+    const path = windowsStartupCmdPath();
+    if (existsSync(path))
+        unlinkSync(path);
+    return { path, installed: false };
+}
+export function installLoginService() {
+    const platform = servicePlatform();
+    if (platform === "darwin")
+        return { ...installDarwin(), platform };
+    if (platform === "linux")
+        return { ...installLinux(), platform };
+    if (platform === "win32")
+        return { ...installWindows(), platform };
+    throw new Error("Login auto-start is not supported on this OS.");
+}
+export function uninstallLoginService() {
+    const platform = servicePlatform();
+    if (platform === "darwin")
+        return { ...uninstallDarwin(), platform };
+    if (platform === "linux")
+        return { ...uninstallLinux(), platform };
+    if (platform === "win32")
+        return { ...uninstallWindows(), platform };
+    return { path: serviceInstallPath(), installed: false, platform };
+}

package/dist/shop.d.ts

@@ -0,0 +1,9 @@
+/** Public shop URL for the local UI. The seller process is not part of the CLI. */
+export declare function shopStatus(): {
+    url: string;
+    enabled: boolean;
+    proUrl: string;
+    itUrl: string;
+    proPrice: string;
+    itPrice: string;
+};

package/dist/shop.js

@@ -0,0 +1,15 @@
+/** Public shop URL for the local UI. The seller process is not part of the CLI. */
+export function shopStatus() {
+    const url = (process.env.AMEM_SHOP_URL || "https://getamem.com").replace(/\/$/, "");
+    const disabled = String(process.env.AMEM_SHOP_LOCAL || "").trim() === "0";
+    const proCents = Number(process.env.STRIPE_AMOUNT_PRO_CENTS || 1200);
+    const itCents = Number(process.env.STRIPE_AMOUNT_IT_CENTS || 4900);
+    return {
+        url,
+        enabled: !disabled,
+        proUrl: `${url}/buy/pro`,
+        itUrl: `${url}/buy/it`,
+        proPrice: `$${(proCents / 100).toFixed(0)}`,
+        itPrice: `$${(itCents / 100).toFixed(0)}`,
+    };
+}

package/dist/ui/server.d.ts

@@ -0,0 +1,21 @@
+export type UiServerOptions = {
+    port?: number;
+    cwd?: string;
+    openBrowser?: boolean;
+    /** Loopback only — non-loopback values are forced to 127.0.0.1 */
+    host?: string;
+    landingUrl?: string;
+};
+export declare function buildUiLandingUrl(port: number, cwd: string): string;
+export declare function openUiInBrowser(url: string): void;
+export declare function isAddrInUse(error: unknown): boolean;
+export declare function probeUiHealth(port: number, host?: string): Promise<{
+    reachable: boolean;
+    hasVault: boolean;
+    features: string[];
+}>;
+export declare function startUiServer(options?: UiServerOptions): Promise<{
+    port: number;
+    url: string;
+    close: () => Promise<void>;
+}>;

package/dist/ui/server.js

@@ -0,0 +1,268 @@
+import { createServer } from "node:http";
+import { readFileSync, existsSync, statSync } from "node:fs";
+import { extname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { execFile } from "node:child_process";
+import { handleApi } from "../api/routes.js";
+import { detectRepoIdentity } from "../repo-identity.js";
+import { handleMcpHttpBody, isJsonRpcMessage } from "../mcp.js";
+const MIME = {
+    ".html": "text/html; charset=utf-8",
+    ".js": "text/javascript; charset=utf-8",
+    ".css": "text/css; charset=utf-8",
+    ".svg": "image/svg+xml",
+    ".json": "application/json",
+    ".map": "application/json",
+};
+function uiRoot() {
+    // dist/ui/server.js -> package root is ../..
+    const here = fileURLToPath(new URL(".", import.meta.url));
+    const packageRoot = join(here, "..", "..");
+    const viteDist = join(packageRoot, "dist", "ui-app");
+    const staticFallback = join(packageRoot, "ui-static");
+    if (existsSync(join(viteDist, "index.html")))
+        return viteDist;
+    if (existsSync(join(staticFallback, "index.html")))
+        return staticFallback;
+    return staticFallback;
+}
+async function readBody(req) {
+    const chunks = [];
+    for await (const chunk of req) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    if (chunks.length === 0)
+        return null;
+    const raw = Buffer.concat(chunks).toString("utf8");
+    if (!raw)
+        return null;
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return raw;
+    }
+}
+function sendJson(res, status, body) {
+    const payload = JSON.stringify(body);
+    res.writeHead(status, {
+        "Content-Type": "application/json; charset=utf-8",
+        "Cache-Control": "no-store",
+        "Access-Control-Allow-Origin": "*",
+        "Access-Control-Allow-Methods": "GET, POST, PATCH, DELETE, OPTIONS",
+        "Access-Control-Allow-Headers": "Content-Type, Accept, mcp-session-id, mcp-protocol-version, x-amem-workspace",
+    });
+    res.end(payload);
+}
+const MCP_CORS = {
+    "Access-Control-Allow-Origin": "*",
+    "Access-Control-Allow-Methods": "GET, POST, PATCH, DELETE, OPTIONS",
+    "Access-Control-Allow-Headers": "Content-Type, Accept, mcp-session-id, mcp-protocol-version, x-amem-workspace",
+    "Access-Control-Expose-Headers": "mcp-session-id, mcp-protocol-version",
+};
+function workspaceFromMcpReq(req, url) {
+    const q = url.searchParams.get("workspace")?.trim();
+    if (q)
+        return q;
+    const header = req.headers["x-amem-workspace"];
+    if (typeof header === "string" && header.trim())
+        return header.trim();
+    return process.env.AMEM_WORKSPACE || undefined;
+}
+function sendMcp(res, req, body, workspace) {
+    const handled = handleMcpHttpBody(body, workspace);
+    if (handled.status === 202) {
+        res.writeHead(202, MCP_CORS);
+        res.end();
+        return;
+    }
+    const payload = JSON.stringify(handled.body);
+    const accept = String(req.headers.accept ?? "");
+    const preferSse = accept.includes("text/event-stream") && !accept.includes("application/json");
+    if (preferSse) {
+        res.writeHead(handled.status, {
+            "Content-Type": "text/event-stream",
+            "Cache-Control": "no-cache",
+            Connection: "keep-alive",
+            ...MCP_CORS,
+        });
+        res.end(`event: message\ndata: ${payload}\n\n`);
+        return;
+    }
+    res.writeHead(handled.status, {
+        "Content-Type": "application/json; charset=utf-8",
+        "Cache-Control": "no-store",
+        ...MCP_CORS,
+    });
+    res.end(payload);
+}
+function serveStatic(res, urlPath) {
+    const root = uiRoot();
+    let rel = urlPath === "/" ? "/index.html" : urlPath;
+    rel = rel.split("?")[0] ?? rel;
+    const filePath = join(root, rel.replace(/^\//, ""));
+    if (!filePath.startsWith(root) || !existsSync(filePath) || !statSync(filePath).isFile()) {
+        // A missing asset must 404: falling back to index.html would hand the browser
+        // HTML with a JS content type and fail the module load for an unclear reason.
+        const ext = extname(filePath);
+        if (ext && ext !== ".html") {
+            res.writeHead(404, { "Content-Type": "text/plain; charset=utf-8" }).end("Not found");
+            return;
+        }
+        // SPA fallback
+        const index = join(root, "index.html");
+        if (existsSync(index)) {
+            res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+            res.end(readFileSync(index));
+            return;
+        }
+        res.writeHead(404).end("UI not built. Run npm run build.");
+        return;
+    }
+    const type = MIME[extname(filePath)] ?? "application/octet-stream";
+    const noStore = filePath.endsWith(".js") ||
+        filePath.endsWith(".css") ||
+        filePath.endsWith(".html") ||
+        filePath.endsWith("index.html");
+    res.writeHead(200, {
+        "Content-Type": type,
+        ...(noStore ? { "Cache-Control": "no-store" } : {}),
+    });
+    res.end(readFileSync(filePath));
+}
+function resolveLoopbackHost(host) {
+    if (!host || host === "localhost" || host === "127.0.0.1")
+        return "127.0.0.1";
+    return "127.0.0.1";
+}
+export function buildUiLandingUrl(port, cwd) {
+    const identity = detectRepoIdentity(cwd);
+    const q = new URLSearchParams();
+    q.set("tab", "setup");
+    q.set("scope", "all");
+    q.set("path", identity.rootPath);
+    return `http://127.0.0.1:${port}/?${q.toString()}`;
+}
+export function openUiInBrowser(url) {
+    try {
+        if (process.platform === "darwin")
+            execFile("open", [url]);
+        else if (process.platform === "win32")
+            execFile("cmd", ["/c", "start", url]);
+        else
+            execFile("xdg-open", [url]);
+    }
+    catch {
+        // ignore
+    }
+}
+export function isAddrInUse(error) {
+    return (typeof error === "object" &&
+        error !== null &&
+        "code" in error &&
+        error.code === "EADDRINUSE");
+}
+export async function probeUiHealth(port, host = "127.0.0.1") {
+    try {
+        const res = await fetch(`http://${host}:${port}/api/health`, {
+            signal: AbortSignal.timeout(1000),
+        });
+        if (res.ok) {
+            const body = (await res.json());
+            const features = Array.isArray(body.features)
+                ? body.features.filter((f) => typeof f === "string")
+                : [];
+            return { reachable: true, hasVault: features.includes("vault"), features };
+        }
+    }
+    catch {
+        // older builds have no /api/health
+    }
+    try {
+        const res = await fetch(`http://${host}:${port}/api/vault`, {
+            signal: AbortSignal.timeout(1000),
+        });
+        return { reachable: true, hasVault: res.ok, features: res.ok ? ["vault"] : [] };
+    }
+    catch {
+        return { reachable: false, hasVault: false, features: [] };
+    }
+}
+export async function startUiServer(options = {}) {
+    const requestedPort = options.port ?? 7843;
+    const cwd = options.cwd ?? process.cwd();
+    const listenHost = resolveLoopbackHost(options.host);
+    const server = createServer(async (req, res) => {
+        try {
+            const host = req.headers.host ?? `${listenHost}:${requestedPort}`;
+            const url = new URL(req.url ?? "/", `http://${host}`);
+            if (req.method === "OPTIONS") {
+                res.writeHead(204, MCP_CORS);
+                res.end();
+                return;
+            }
+            const mcpPath = url.pathname === "/mcp" || url.pathname === "/sse";
+            if (mcpPath && req.method === "GET") {
+                res.writeHead(200, {
+                    "Content-Type": "text/event-stream",
+                    "Cache-Control": "no-cache",
+                    Connection: "keep-alive",
+                    ...MCP_CORS,
+                });
+                res.write(": amem mcp\n\n");
+                req.on("close", () => res.end());
+                return;
+            }
+            if (mcpPath && req.method === "DELETE") {
+                res.writeHead(204, MCP_CORS);
+                res.end();
+                return;
+            }
+            if (url.pathname.startsWith("/api/")) {
+                const body = req.method === "GET" || req.method === "HEAD" ? null : await readBody(req);
+                const result = handleApi({
+                    method: req.method ?? "GET",
+                    pathname: url.pathname,
+                    searchParams: url.searchParams,
+                    body,
+                    cwd,
+                });
+                sendJson(res, result.status, result.body);
+                return;
+            }
+            if (mcpPath && req.method === "POST") {
+                sendMcp(res, req, await readBody(req), workspaceFromMcpReq(req, url));
+                return;
+            }
+            if (req.method === "POST") {
+                const body = await readBody(req);
+                if (isJsonRpcMessage(body)) {
+                    sendMcp(res, req, body, workspaceFromMcpReq(req, url));
+                    return;
+                }
+            }
+            serveStatic(res, url.pathname);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            sendJson(res, 500, { error: message });
+        }
+    });
+    await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(requestedPort, listenHost, () => resolve());
+    });
+    const addr = server.address();
+    const port = typeof addr === "object" && addr ? addr.port : requestedPort;
+    const url = options.landingUrl ?? `http://${listenHost}:${port}`;
+    if (options.openBrowser !== false) {
+        openUiInBrowser(url);
+    }
+    return {
+        port,
+        url,
+        close: () => new Promise((resolve, reject) => {
+            server.close((err) => (err ? reject(err) : resolve()));
+        }),
+    };
+}

package/dist/vault.d.ts

@@ -0,0 +1,25 @@
+export type BackupEntry = {
+    name: string;
+    path: string;
+    bytes: number;
+    mtime: string;
+    encrypted: boolean;
+};
+export type VaultStatus = {
+    dbPath: string;
+    encryptedAtRest: boolean;
+    unlocked: boolean;
+    encCopyPresent: boolean;
+    encryptionConfigured: boolean;
+    backup: {
+        dir: string;
+        scheduled: boolean;
+        schedulePath: string;
+        last: BackupEntry | null;
+        recent: BackupEntry[];
+        count: number;
+    };
+};
+export declare function listBackups(dir?: string): BackupEntry[];
+/** Lock/backup chrome — does not open the SQLite DB (works while locked). */
+export declare function vaultStatus(): VaultStatus;

package/dist/vault.js

@@ -0,0 +1,42 @@
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { defaultBackupDir, encryptedDbPath, encryptionConfigured, isDbEncryptedAtRest, } from "./crypto.js";
+import { backupSchedulePath, isBackupScheduleInstalled } from "./backup-schedule.js";
+import { dbPath } from "./paths.js";
+export function listBackups(dir = defaultBackupDir()) {
+    if (!existsSync(dir))
+        return [];
+    return readdirSync(dir)
+        .filter((name) => name.endsWith(".db") || name.endsWith(".db.enc"))
+        .map((name) => {
+        const path = join(dir, name);
+        const st = statSync(path);
+        return {
+            name,
+            path,
+            bytes: st.size,
+            mtime: st.mtime.toISOString(),
+            encrypted: name.endsWith(".enc"),
+        };
+    })
+        .sort((a, b) => b.mtime.localeCompare(a.mtime));
+}
+/** Lock/backup chrome — does not open the SQLite DB (works while locked). */
+export function vaultStatus() {
+    const backups = listBackups();
+    return {
+        dbPath: dbPath(),
+        encryptedAtRest: isDbEncryptedAtRest(),
+        unlocked: existsSync(dbPath()),
+        encCopyPresent: existsSync(encryptedDbPath()),
+        encryptionConfigured: encryptionConfigured(),
+        backup: {
+            dir: defaultBackupDir(),
+            scheduled: isBackupScheduleInstalled(),
+            schedulePath: isBackupScheduleInstalled() ? backupSchedulePath() : "",
+            last: backups[0] ?? null,
+            recent: backups.slice(0, 8),
+            count: backups.length,
+        },
+    };
+}

package/dist/workspace-setup.d.ts

@@ -0,0 +1,8 @@
+import { type RepoRow } from "./db.js";
+export type WorkspaceReady = {
+    workspace: string;
+    seeded: number;
+    contextOk: boolean;
+    checks: string[];
+};
+export declare function provisionWorkspace(repo: RepoRow, platform?: string): WorkspaceReady;