@phren/cli 0.0.23 → 0.0.25

package/mcp/dist/init-setup.js

@@ -290,9 +290,10 @@ export function repairPreexistingInstall(phrenPath) {
 function isExpectedVerifyFailure(phrenPath, check) {
     if (check.ok)
         return false;
-    if (check.name === "git-remote")
-        return true;
     const prefs = readInstallPreferences(phrenPath);
+    // git-remote failure is only expected when the user chose local-only (no clone URL)
+    if (check.name === "git-remote")
+        return prefs.syncIntent !== "sync";
     if (check.name === "mcp-config" && prefs.mcpEnabled === false)
         return true;
     if (check.name === "hooks-registered" && prefs.hooksEnabled === false)
@@ -339,17 +340,30 @@ function gitRemoteStatus(phrenPath) {
     catch {
         return { ok: false, detail: "phren path is not a git repository" };
     }
+    let remote;
     try {
-        const remote = execFileSync("git", ["-C", phrenPath, "remote", "get-url", "origin"], {
+        remote = execFileSync("git", ["-C", phrenPath, "remote", "get-url", "origin"], {
             encoding: "utf8",
             stdio: ["ignore", "pipe", "ignore"],
             timeout: EXEC_TIMEOUT_QUICK_MS,
         }).trim();
-        return remote ? { ok: true, detail: `origin=${remote}` } : { ok: false, detail: "git origin remote not configured" };
+        if (!remote)
+            return { ok: false, detail: "git origin remote not configured" };
     }
     catch {
         return { ok: false, detail: "git origin remote not configured" };
     }
+    // Connectivity test: verify the remote is reachable (10s timeout)
+    try {
+        execFileSync("git", ["-C", phrenPath, "ls-remote", "--exit-code", "origin"], {
+            stdio: ["ignore", "ignore", "ignore"],
+            timeout: 10_000,
+        });
+        return { ok: true, detail: `origin=${remote}` };
+    }
+    catch {
+        return { ok: false, detail: `origin=${remote} (configured but unreachable)` };
+    }
 }
 function copyStarterFile(phrenPath, src, dest) {
     fs.mkdirSync(path.dirname(dest), { recursive: true });
@@ -1147,14 +1161,22 @@ export function runPostInitVerify(phrenPath) {
     }
     else {
         const gitRemote = gitRemoteStatus(phrenPath);
+        const wantSync = prefs.syncIntent === "sync";
         const gitRemoteDetail = gitRemote.ok
             ? gitRemote.detail
-            : `${gitRemote.detail} (optional unless you want cross-machine sync)`;
+            : wantSync
+                ? `${gitRemote.detail} — sync was configured but remote is missing or unreachable`
+                : `${gitRemote.detail} (optional unless you want cross-machine sync)`;
+        const gitRemoteFix = gitRemote.ok
+            ? undefined
+            : wantSync
+                ? `Your clone URL didn't work. Fix: cd ${phrenPath} && git remote add origin <URL> && git push -u origin main`
+                : "Optional: initialize a repo and add an origin remote for cross-machine sync.";
         checks.push({
             name: "git-remote",
             ok: gitRemote.ok,
             detail: gitRemoteDetail,
-            fix: gitRemote.ok ? undefined : "Optional: initialize a repo and add an origin remote for cross-machine sync.",
+            fix: gitRemoteFix,
         });
         const settingsPath = hookConfigPath("claude");
         const configWritable = nearestWritableTarget(settingsPath);

package/mcp/dist/init.js

@@ -5,7 +5,7 @@
 import * as fs from "fs";
 import * as path from "path";
 import * as crypto from "crypto";
-import { execFileSync } from "child_process";
+import { execFileSync, spawnSync } from "child_process";
 import { configureAllHooks } from "./hooks.js";
 import { getMachineName, machineFilePath, persistMachineName } from "./machine-identity.js";
 import { atomicWriteText, debugLog, isRecord, hookConfigPath, homeDir, homePath, expandHomePath, findPhrenPath, getProjectDirs, readRootManifest, writeRootManifest, } from "./shared.js";
@@ -24,6 +24,7 @@ import { DEFAULT_PHREN_PATH, STARTER_DIR, VERSION, log, confirmPrompt } from "./
 import { PROJECT_OWNERSHIP_MODES, getProjectOwnershipDefault, } from "./project-config.js";
 import { getWorkflowPolicy, updateWorkflowPolicy } from "./shared-governance.js";
 import { addProjectToProfile } from "./profile-store.js";
+const PHREN_NPM_PACKAGE_NAME = "@phren/cli";
 function parseVersion(version) {
     const match = version.trim().match(/^(\d+)\.(\d+)\.(\d+)(?:-(.+))?/);
     if (!match)
@@ -58,6 +59,56 @@ export function isVersionNewer(current, previous) {
         return true;
     return c.pre > p.pre;
 }
+function getNpmCommand() {
+    return process.platform === "win32" ? "npm.cmd" : "npm";
+}
+function runSyncCommand(command, args) {
+    try {
+        const result = spawnSync(command, args, {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        return {
+            ok: result.status === 0,
+            status: result.status,
+            stdout: typeof result.stdout === "string" ? result.stdout : "",
+            stderr: typeof result.stderr === "string" ? result.stderr : "",
+        };
+    }
+    catch (err) {
+        return {
+            ok: false,
+            status: null,
+            stdout: "",
+            stderr: errorMessage(err),
+        };
+    }
+}
+function shouldUninstallCurrentGlobalPackage() {
+    const entryScript = process.argv[1];
+    if (!entryScript)
+        return false;
+    const npmRootResult = runSyncCommand(getNpmCommand(), ["root", "-g"]);
+    if (!npmRootResult.ok)
+        return false;
+    const npmRoot = npmRootResult.stdout.trim();
+    if (!npmRoot)
+        return false;
+    const resolvedEntryScript = path.resolve(entryScript);
+    const resolvedGlobalPackageRoot = path.resolve(path.join(npmRoot, PHREN_NPM_PACKAGE_NAME));
+    return resolvedEntryScript === resolvedGlobalPackageRoot
+        || resolvedEntryScript.startsWith(`${resolvedGlobalPackageRoot}${path.sep}`);
+}
+function uninstallCurrentGlobalPackage() {
+    const result = runSyncCommand(getNpmCommand(), ["uninstall", "-g", PHREN_NPM_PACKAGE_NAME]);
+    if (result.ok) {
+        log(`  Removed global npm package (${PHREN_NPM_PACKAGE_NAME})`);
+        return;
+    }
+    const detail = result.stderr.trim() || result.stdout.trim() || (result.status === null ? "failed to start command" : `exit code ${result.status}`);
+    log(`  Warning: could not remove global npm package (${PHREN_NPM_PACKAGE_NAME})`);
+    debugLog(`uninstall: global npm cleanup failed: ${detail}`);
+}
 export function parseMcpMode(raw) {
     if (!raw)
         return undefined;
@@ -1037,9 +1088,23 @@ export async function runInit(opts = {}) {
         }
         catch (e) {
             log(`  Clone failed: ${e instanceof Error ? e.message : String(e)}`);
-            log(`  Continuing with fresh install instead.`);
+            log("");
+            log("  ┌──────────────────────────────────────────────────────────────────┐");
+            log("  │  WARNING: Sync is NOT configured. Your phren data is local-only. │");
+            log("  │                                                                  │");
+            log("  │  To fix later:                                                   │");
+            log(`  │    cd ${phrenPath}`);
+            log("  │    git remote add origin <YOUR_REPO_URL>                         │");
+            log("  │    git push -u origin main                                       │");
+            log("  └──────────────────────────────────────────────────────────────────┘");
+            log("");
+            log(`  Continuing with fresh local-only install.`);
         }
     }
+    // Record sync intent: "sync" if a clone URL was provided (regardless of success), "local" otherwise.
+    // On re-runs of existing installs, preserve the existing syncIntent unless the user provided a new clone URL.
+    const existingSyncIntent = hasExistingInstall ? readInstallPreferences(phrenPath).syncIntent : undefined;
+    const syncIntent = opts._walkthroughCloneUrl ? "sync" : (existingSyncIntent ?? "local");
     const mcpEnabled = opts.mcp ? opts.mcp === "on" : getMcpEnabledPreference(phrenPath);
     const hooksEnabled = opts.hooks ? opts.hooks === "on" : getHooksEnabledPreference(phrenPath);
     const skillsScope = opts.skillsScope ?? "global";
@@ -1194,7 +1259,7 @@ export async function runInit(opts = {}) {
                 log(`  No starter template updates were applied (starter files not found).`);
             }
         }
-        writeInstallPreferences(phrenPath, { mcpEnabled, hooksEnabled, skillsScope, installedVersion: VERSION });
+        writeInstallPreferences(phrenPath, { mcpEnabled, hooksEnabled, skillsScope, installedVersion: VERSION, syncIntent });
         if (repaired.removedLegacyProjects > 0) {
             log(`  Removed ${repaired.removedLegacyProjects} legacy starter project entr${repaired.removedLegacyProjects === 1 ? "y" : "ies"} from profiles.`);
         }
@@ -1372,7 +1437,7 @@ export async function runInit(opts = {}) {
     // Configure MCP for all detected AI coding tools and hooks
     configureMcpTargets(phrenPath, { mcpEnabled, hooksEnabled }, "Configured");
     configureHooksIfEnabled(phrenPath, hooksEnabled, "Configured");
-    writeInstallPreferences(phrenPath, { mcpEnabled, hooksEnabled, skillsScope, installedVersion: VERSION });
+    writeInstallPreferences(phrenPath, { mcpEnabled, hooksEnabled, skillsScope, installedVersion: VERSION, syncIntent });
     // Post-init verification
     log(`\nVerifying setup...`);
     const verify = runPostInitVerify(phrenPath);
@@ -1718,6 +1783,7 @@ export async function runUninstall(opts = {}) {
         return;
     }
     log("\nUninstalling phren...\n");
+    const shouldRemoveGlobalPackage = shouldUninstallCurrentGlobalPackage();
     // Confirmation prompt (shared-mode only — project-local is low-stakes)
     if (!opts.yes) {
         const confirmed = phrenPath
@@ -1910,6 +1976,16 @@ export async function runUninstall(opts = {}) {
     catch (err) {
         debugLog(`uninstall: cleanup failed for ${machineFile}: ${errorMessage(err)}`);
     }
+    const contextFile = homePath(".phren-context.md");
+    try {
+        if (fs.existsSync(contextFile)) {
+            fs.unlinkSync(contextFile);
+            log(`  Removed machine context file (${contextFile})`);
+        }
+    }
+    catch (err) {
+        debugLog(`uninstall: cleanup failed for ${contextFile}: ${errorMessage(err)}`);
+    }
     // Sweep agent skill directories for symlinks pointing into the phren store
     if (phrenPath) {
         try {
@@ -1929,6 +2005,9 @@ export async function runUninstall(opts = {}) {
             log(`  Warning: could not remove phren root (${phrenPath})`);
         }
     }
+    if (shouldRemoveGlobalPackage) {
+        uninstallCurrentGlobalPackage();
+    }
     log(`\nPhren config, hooks, and installed data removed.`);
     log(`Restart your agent(s) to apply changes.\n`);
 }

package/mcp/dist/mcp-ops.js

@@ -163,15 +163,52 @@ export function register(server, ctx) {
             if ((process.env.PHREN_DEBUG))
                 process.stderr.write(`[phren] healthCheck taskMode: ${errorMessage(err)}\n`);
         }
+        let syncIntent;
         try {
             const { readInstallPreferences } = await import("./init-preferences.js");
             const prefs = readInstallPreferences(phrenPath);
             proactivity = prefs.proactivity || "high";
+            syncIntent = prefs.syncIntent;
         }
         catch (err) {
             if ((process.env.PHREN_DEBUG))
                 process.stderr.write(`[phren] healthCheck proactivity: ${errorMessage(err)}\n`);
         }
+        // Determine sync status from intent + git remote state
+        let syncStatus = "local-only";
+        let syncDetail = "no git remote configured";
+        try {
+            const { execFileSync } = await import("child_process");
+            const remote = execFileSync("git", ["-C", phrenPath, "remote", "get-url", "origin"], {
+                encoding: "utf8",
+                stdio: ["ignore", "pipe", "ignore"],
+                timeout: 5_000,
+            }).trim();
+            if (remote) {
+                try {
+                    execFileSync("git", ["-C", phrenPath, "ls-remote", "--exit-code", "origin"], {
+                        stdio: ["ignore", "ignore", "ignore"],
+                        timeout: 10_000,
+                    });
+                    syncStatus = "synced";
+                    syncDetail = `origin=${remote}`;
+                }
+                catch {
+                    syncStatus = syncIntent === "sync" ? "broken" : "local-only";
+                    syncDetail = `origin=${remote} (unreachable)`;
+                }
+            }
+            else if (syncIntent === "sync") {
+                syncStatus = "broken";
+                syncDetail = "sync was configured but no remote found";
+            }
+        }
+        catch {
+            if (syncIntent === "sync") {
+                syncStatus = "broken";
+                syncDetail = "sync was configured but no remote found";
+            }
+        }
         const lines = [
             `Phren v${version}`,
             `Profile: ${activeProfile || "(default)"}`,
@@ -182,6 +219,7 @@ export function register(server, ctx) {
             `Hooks: ${hooksEnabled ? "enabled" : "disabled"}`,
             `Proactivity: ${proactivity}`,
             `Task mode: ${taskMode}`,
+            `Sync: ${syncStatus}${syncStatus !== "synced" ? ` (${syncDetail})` : ""}`,
             `Path: ${phrenPath}`,
         ].filter(Boolean);
         return mcpResponse({
@@ -197,6 +235,8 @@ export function register(server, ctx) {
                 hooksEnabled,
                 proactivity,
                 taskMode,
+                syncStatus,
+                syncDetail,
                 phrenPath,
             },
         });