sloppydisk 0.1.2 → 0.1.3

package/lib/patcher.js

@@ -2,30 +2,28 @@ const crypto = require("node:crypto");
 const fs = require("node:fs");
 const os = require("node:os");
 const path = require("node:path");
-const { Readable } = require("node:stream");
-const { pipeline } = require("node:stream/promises");
 const { spawnSync } = require("node:child_process");
 
 const PACKAGE_ROOT = path.resolve(__dirname, "..");
 const PACKAGE_JSON = require(path.join(PACKAGE_ROOT, "package.json"));
-const WORK_ROOT = path.join(os.homedir(), ".slopex");
+const WORK_ROOT = path.join(os.homedir(), ".sloppydisk");
+const SRC_ROOT = path.join(WORK_ROOT, "src");
 const BACKUP_ROOT = path.join(WORK_ROOT, "backups");
 const ARTIFACT_ROOT = path.join(WORK_ROOT, "artifacts");
-const BUNDLED_ARTIFACT_ROOT = path.join(PACKAGE_ROOT, "artifacts");
 const INSTALL_STATE_PATH = path.join(WORK_ROOT, "install-state.json");
 const CONFIG_PATH = path.join(os.homedir(), ".codex", "config.toml");
 const CONTINUITY_ROOT = path.join(os.homedir(), ".codex", "obsidian_graph");
 const CHILD_ENV = createChildEnv();
 
 const SUPPORTED_CODEX_VERSIONS = ["0.117.0"];
+const CODEX_SRC_URL = "https://github.com/openai/codex.git";
 
 async function installSlopex({ postinstall = false } = {}) {
   ensureDir(WORK_ROOT);
 
   const codexInstall = resolveCodexInstall();
   if (!codexInstall) {
-    const message =
-      "Codex is not installed globally. Install it first with: npm install -g @openai/codex";
+    const message = "Codex is not installed globally. Install it first with: npm install -g @openai/codex";
     if (postinstall) {
       console.warn(`[sloppydisk] ${message}`);
       return;
@@ -35,35 +33,12 @@ async function installSlopex({ postinstall = false } = {}) {
 
   assertSupportedCodexVersion(codexInstall.version);
 
-  const patchedBinary = await resolvePatchedBinary(codexInstall.version);
-  if (!patchedBinary) {
-    const message = [
-      `No prebuilt sloppydisk binary is available for Codex ${codexInstall.version} on ${artifactPlatformKey()}.`,
-      "Install a slopex release that publishes this artifact, or place a matching binary under ~/.slopex/artifacts and rerun `sloppydisk patch`."
-    ].join(" ");
-    if (postinstall) {
-      console.warn(`[sloppydisk] ${message}`);
-      return;
-    }
-    throw new Error(message);
-  }
+  console.log(`[sloppydisk] Preparing to patch Codex ${codexInstall.version} locally...`);
+  const patchedBinary = await buildPatchedBinaryLocally(codexInstall.version);
 
   ensureDir(BACKUP_ROOT);
   const backupBinary = path.join(BACKUP_ROOT, `codex-${codexInstall.version}.original`);
-  const originalBinarySha256 = sha256File(codexInstall.vendorBinary);
-  const patchedBinarySha256 = sha256File(patchedBinary);
   if (!fs.existsSync(backupBinary)) {
-    if (originalBinarySha256 === patchedBinarySha256) {
-      const message = [
-        "Codex already appears to be patched, but slopex could not find an original backup to restore later.",
-        "Refusing to overwrite the only copy. Reinstall @openai/codex first, then rerun `sloppydisk patch`."
-      ].join(" ");
-      if (postinstall) {
-        console.warn(`[sloppydisk] ${message}`);
-        return;
-      }
-      throw new Error(message);
-    }
     fs.copyFileSync(codexInstall.vendorBinary, backupBinary);
   }
 
@@ -72,24 +47,67 @@ async function installSlopex({ postinstall = false } = {}) {
 
   const state = {
     installedAt: new Date().toISOString(),
-    slopexVersion: PACKAGE_JSON.version,
+    version: PACKAGE_JSON.version,
     codexVersion: codexInstall.version,
-    codexDir: codexInstall.codexDir,
     vendorBinary: codexInstall.vendorBinary,
     backupBinary,
     artifactBinary: patchedBinary,
-    originalBinarySha256,
-    patchedBinarySha256: sha256File(codexInstall.vendorBinary),
     binarySha256: sha256File(codexInstall.vendorBinary)
   };
   fs.writeFileSync(INSTALL_STATE_PATH, `${JSON.stringify(state, null, 2)}\n`);
 
   console.log(`sloppydisk patched Codex ${codexInstall.version}`);
   console.log(`patched binary: ${codexInstall.vendorBinary}`);
-  console.log(`artifact source: ${patchedBinary}`);
   console.log(`continuity root: ${CONTINUITY_ROOT}`);
 }
 
+async function buildPatchedBinaryLocally(version) {
+  const repoDir = path.join(SRC_ROOT, `rust-v${version}`);
+  const artifactPath = path.join(ARTIFACT_ROOT, version, artifactPlatformKey(), executableName("codex"));
+  const devSourceDir = "/root/codex-src-main"; // Known local dev source
+
+  if (fs.existsSync(artifactPath)) {
+    console.log(`[sloppydisk] Using cached patched binary at ${artifactPath}`);
+    return artifactPath;
+  }
+
+  ensureDir(path.dirname(artifactPath));
+  ensureDir(SRC_ROOT);
+
+  if (!fs.existsSync(repoDir)) {
+    if (fs.existsSync(devSourceDir)) {
+       console.log(`[sloppydisk] Linking local development source from ${devSourceDir}...`);
+       fs.symlinkSync(devSourceDir, repoDir, 'dir');
+    } else {
+       console.log(`[sloppydisk] Cloning Codex source to ${repoDir}...`);
+       // Note: Standard OpenAI codex tags are often just 'vX.Y.Z'
+       runChecked("git", ["clone", "--depth", "1", "--branch", `v${version}`, CODEX_SRC_URL, repoDir]);
+    }
+  }
+
+  const patchFile = path.join(PACKAGE_ROOT, "patches", `rust-v${version}.patch`);
+  if (!fs.existsSync(patchFile)) {
+    throw new Error(`Missing patch file for version ${version} at ${patchFile}`);
+  }
+
+  console.log(`[sloppydisk] Applying patch ${path.basename(patchFile)}...`);
+  runChecked("git", ["reset", "--hard"], { cwd: repoDir });
+  runChecked("patch", ["-p1", "-i", patchFile], { cwd: repoDir });
+
+  console.log(`[sloppydisk] Compiling patched Codex (this may take a few minutes)...`);
+  const crateDir = path.join(repoDir, "codex-rs");
+  runChecked("cargo", ["build", "--release", "-p", "codex-cli", "--bin", "codex"], { cwd: crateDir });
+
+  const buildOutput = path.join(crateDir, "target", "release", executableName("codex"));
+  if (!fs.existsSync(buildOutput)) {
+    throw new Error(`Build failed: could not find output at ${buildOutput}`);
+  }
+
+  fs.copyFileSync(buildOutput, artifactPath);
+  console.log(`[sloppydisk] Successfully built and cached patched binary.`);
+  return artifactPath;
+}
+
 async function printStatus() {
   const codexInstall = resolveCodexInstall();
   if (!codexInstall) {
@@ -103,94 +121,56 @@ async function printStatus() {
 
   console.log(`codex version: ${codexInstall.version}`);
   console.log(`codex dir: ${codexInstall.codexDir}`);
-  console.log(`codex vendor binary: ${codexInstall.vendorBinary}`);
   console.log(`supported by sloppydisk: ${SUPPORTED_CODEX_VERSIONS.includes(codexInstall.version)}`);
   console.log(`sloppydisk config block: ${managedConfigPresent ? "present" : "missing"}`);
-  console.log(
-    `bundled artifact: ${resolveArtifactCandidate(codexInstall.version, BUNDLED_ARTIFACT_ROOT) || "missing"}`
-  );
-  console.log(
-    `cached artifact: ${resolveArtifactCandidate(codexInstall.version, ARTIFACT_ROOT) || "missing"}`
-  );
-  console.log(`release asset url: ${releaseArtifactUrl(codexInstall.version)}`);
 
   if (!state) {
     console.log("sloppydisk install state: not found");
     return;
   }
 
-  console.log(`sloppydisk version: ${state.slopexVersion}`);
-  console.log(`artifact binary: ${state.artifactBinary || "unknown"}`);
+  console.log(`sloppydisk version: ${state.version}`);
   console.log(`backup binary: ${state.backupBinary}`);
-  console.log(
-    `patched binary hash matches state: ${sha256File(codexInstall.vendorBinary) === state.binarySha256}`
-  );
+  console.log(`patched binary hash matches state: ${sha256File(codexInstall.vendorBinary) === state.binarySha256}`);
 }
 
 async function uninstallSlopex() {
   const state = readInstallState();
-  const codexInstall = resolveCodexInstall();
-  const targetVersion = codexInstall?.version || state?.codexVersion;
-  if (!state && !targetVersion) {
-    throw new Error("No sloppydisk install state was found and Codex is not installed globally. Nothing to uninstall.");
+  if (!state) {
+    throw new Error("No sloppydisk install state found.");
   }
 
-  if (canRestoreFromBackup({ state, codexInstall })) {
+  if (fs.existsSync(state.backupBinary)) {
     replaceBinaryAtomically(state.backupBinary, state.vendorBinary);
-    removeManagedConfigBlock();
-    fs.rmSync(INSTALL_STATE_PATH, { force: true });
     console.log(`Restored original Codex binary from ${state.backupBinary}`);
-    return;
+  } else {
+    console.warn(`Backup not found at ${state.backupBinary}. Reinstalling @openai/codex...`);
+    reinstallOfficialCodex(state.codexVersion);
   }
 
-  reinstallOfficialCodex(targetVersion);
   removeManagedConfigBlock();
   fs.rmSync(INSTALL_STATE_PATH, { force: true });
-  console.log(`Reinstalled official Codex ${targetVersion} from npm.`);
-}
-
-function assertSupportedCodexVersion(version) {
-  if (SUPPORTED_CODEX_VERSIONS.includes(version)) {
-    return;
-  }
-
-  throw new Error(
-    `Codex ${version} is not supported by this sloppydisk release. Supported versions: ${SUPPORTED_CODEX_VERSIONS.join(", ")}`
-  );
 }
 
 function resolveCodexInstall() {
-  const npmRoot = runChecked("npm", ["root", "-g"]).stdout.trim();
-  const codexDir = path.join(npmRoot, "@openai", "codex");
-  if (!fs.existsSync(codexDir)) {
-    return null;
-  }
+  try {
+    const npmRoot = runChecked("npm", ["root", "-g"]).stdout.trim();
+    const codexDir = path.join(npmRoot, "@openai", "codex");
+    if (!fs.existsSync(codexDir)) return null;
 
-  const packageJsonPath = path.join(codexDir, "package.json");
-  if (!fs.existsSync(packageJsonPath)) {
-    throw new Error(`Could not find Codex package.json at ${packageJsonPath}`);
-  }
+    const packageJson = JSON.parse(fs.readFileSync(path.join(codexDir, "package.json"), "utf8"));
+    const vendorBinary = findVendorBinary(codexDir);
+    if (!vendorBinary) throw new Error("Could not locate Codex vendor binary.");
 
-  const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
-  const vendorBinary = findVendorBinary(codexDir);
-  if (!vendorBinary) {
-    throw new Error(`Could not locate the Codex vendor binary inside ${codexDir}`);
+    return { codexDir, version: packageJson.version, vendorBinary };
+  } catch (e) {
+    return null;
   }
-
-  return {
-    npmRoot,
-    codexDir,
-    version: packageJson.version,
-    vendorBinary
-  };
 }
 
 function findVendorBinary(codexDir) {
   const root = path.join(codexDir, "node_modules");
-  if (!fs.existsSync(root)) {
-    return null;
-  }
-
+  if (!fs.existsSync(root)) return null;
   const queue = [root];
   while (queue.length > 0) {
     const current = queue.shift();
@@ -198,100 +178,21 @@ function findVendorBinary(codexDir) {
       const fullPath = path.join(current, entry.name);
       if (entry.isDirectory()) {
         queue.push(fullPath);
-        continue;
-      }
-      if (
-        entry.isFile() &&
-        entry.name === "codex" &&
-        fullPath.includes(`${path.sep}vendor${path.sep}`) &&
-        fullPath.includes(`${path.sep}codex${path.sep}codex`)
-      ) {
+      } else if (entry.isFile() && entry.name === "codex" && fullPath.includes("vendor")) {
         return fullPath;
       }
     }
   }
-
   return null;
 }
 
 function replaceBinaryAtomically(sourceBinary, targetBinary) {
-  const tempTarget = `${targetBinary}.slopex.tmp`;
+  const tempTarget = `${targetBinary}.tmp`;
   fs.copyFileSync(sourceBinary, tempTarget);
   fs.chmodSync(tempTarget, 0o755);
   fs.renameSync(tempTarget, targetBinary);
 }
 
-async function resolvePatchedBinary(codexVersion) {
-  const localArtifact =
-    resolveArtifactCandidate(codexVersion, BUNDLED_ARTIFACT_ROOT) ||
-    resolveArtifactCandidate(codexVersion, ARTIFACT_ROOT);
-  if (localArtifact) {
-    return localArtifact;
-  }
-
-  return downloadReleaseArtifact(codexVersion, { allowFailure: true });
-}
-
-function resolveArtifactCandidate(codexVersion, rootDir) {
-  const candidate = artifactBinaryPath(rootDir, codexVersion);
-  return fs.existsSync(candidate) ? candidate : null;
-}
-
-function cachedArtifactBinaryPath(codexVersion) {
-  return artifactBinaryPath(ARTIFACT_ROOT, codexVersion);
-}
-
-function artifactBinaryPath(rootDir, codexVersion) {
-  return path.join(rootDir, codexVersion, artifactPlatformKey(), executableName("codex"));
-}
-
-function releaseArtifactName(codexVersion) {
-  return executableName(`sloppydisk-codex-${codexVersion}-${artifactPlatformKey()}`);
-}
-
-function releaseArtifactUrl(codexVersion) {
-  return `https://github.com/${repositorySlug()}/releases/download/v${PACKAGE_JSON.version}/${releaseArtifactName(codexVersion)}`;
-}
-
-function repositorySlug() {
-  const repositoryUrl =
-    typeof PACKAGE_JSON.repository === "string"
-      ? PACKAGE_JSON.repository
-      : PACKAGE_JSON.repository?.url;
-  const match = repositoryUrl && repositoryUrl.match(/github\.com[:/](.+?)(?:\.git)?$/);
-  if (!match) {
-    throw new Error(
-      `Unable to derive GitHub repository slug from package.json repository: ${repositoryUrl}`
-    );
-  }
-  return match[1];
-}
-
-async function downloadReleaseArtifact(codexVersion, { allowFailure = false } = {}) {
-  const targetBinary = cachedArtifactBinaryPath(codexVersion);
-  const tempTarget = `${targetBinary}.download`;
-  const url = releaseArtifactUrl(codexVersion);
-
-  try {
-    ensureDir(path.dirname(targetBinary));
-    const response = await fetch(url, { redirect: "follow" });
-    if (!response.ok || !response.body) {
-      throw new Error(`download failed with HTTP ${response.status} for ${url}`);
-    }
-
-    await pipeline(Readable.fromWeb(response.body), fs.createWriteStream(tempTarget));
-    fs.chmodSync(tempTarget, 0o755);
-    fs.renameSync(tempTarget, targetBinary);
-    return targetBinary;
-  } catch (error) {
-    fs.rmSync(tempTarget, { force: true });
-    if (allowFailure) {
-      return null;
-    }
-    throw error;
-  }
-}
-
 function artifactPlatformKey() {
   return `${process.platform}-${process.arch}`;
 }
@@ -311,80 +212,19 @@ function writeManagedConfigBlock() {
   ].join("\n");
 
   const existing = fs.existsSync(CONFIG_PATH) ? fs.readFileSync(CONFIG_PATH, "utf8") : "";
-  const next = upsertManagedBlock(existing, managedBlock);
-  fs.writeFileSync(CONFIG_PATH, `${next.trimEnd()}\n`);
+  const stripped = existing.replace(/\n?# BEGIN slopex[\s\S]*?# END slopex\n?/g, "\n").trim();
+  fs.writeFileSync(CONFIG_PATH, `${(stripped + "\n\n" + managedBlock).trim()}\n`);
 }
 
 function removeManagedConfigBlock() {
-  if (!fs.existsSync(CONFIG_PATH)) {
-    return;
-  }
-
+  if (!fs.existsSync(CONFIG_PATH)) return;
   const existing = fs.readFileSync(CONFIG_PATH, "utf8");
   const next = existing.replace(/\n?# BEGIN slopex[\s\S]*?# END slopex\n?/g, "\n");
-  fs.writeFileSync(CONFIG_PATH, `${next.trimEnd()}\n`);
-}
-
-function upsertManagedBlock(existing, managedBlock) {
-  const stripped = existing
-    .replace(/\n?# BEGIN slopex[\s\S]*?# END slopex\n?/g, "\n")
-    .trim();
-
-  if (!stripped) {
-    return managedBlock;
-  }
-
-  const firstTableMatch = stripped.match(/^\s*\[/m);
-  if (!firstTableMatch || firstTableMatch.index === undefined) {
-    return `${stripped}\n\n${managedBlock}`;
-  }
-
-  const firstTableIndex = firstTableMatch.index;
-  const prefix = stripped.slice(0, firstTableIndex).trimEnd();
-  const suffix = stripped.slice(firstTableIndex).replace(/^\n+/, "");
-
-  if (!prefix) {
-    return `${managedBlock}\n\n${suffix}`;
-  }
-
-  return `${prefix}\n\n${managedBlock}\n\n${suffix}`;
+  fs.writeFileSync(CONFIG_PATH, `${next.trim()}\n`);
 }
 
 function readInstallState() {
-  if (!fs.existsSync(INSTALL_STATE_PATH)) {
-    return null;
-  }
-  return JSON.parse(fs.readFileSync(INSTALL_STATE_PATH, "utf8"));
-}
-
-function canRestoreFromBackup({ state, codexInstall }) {
-  if (!state || !codexInstall) {
-    return false;
-  }
-  if (codexInstall.version !== state.codexVersion) {
-    return false;
-  }
-  if (codexInstall.vendorBinary !== state.vendorBinary) {
-    return false;
-  }
-  if (!fs.existsSync(state.backupBinary)) {
-    return false;
-  }
-
-  const expectedPatchedSha256 = state.patchedBinarySha256 || state.binarySha256;
-  const currentVendorSha256 = sha256File(codexInstall.vendorBinary);
-  if (expectedPatchedSha256 && currentVendorSha256 !== expectedPatchedSha256) {
-    return false;
-  }
-
-  if (
-    state.originalBinarySha256 &&
-    sha256File(state.backupBinary) !== state.originalBinarySha256
-  ) {
-    return false;
-  }
-
-  return true;
+  return fs.existsSync(INSTALL_STATE_PATH) ? JSON.parse(fs.readFileSync(INSTALL_STATE_PATH, "utf8")) : null;
 }
 
 function reinstallOfficialCodex(version) {
@@ -392,9 +232,7 @@ function reinstallOfficialCodex(version) {
 }
 
 function sha256File(filePath) {
-  const hash = crypto.createHash("sha256");
-  hash.update(fs.readFileSync(filePath));
-  return hash.digest("hex");
+  return crypto.createHash("sha256").update(fs.readFileSync(filePath)).digest("hex");
 }
 
 function ensureDir(dirPath) {
@@ -403,46 +241,19 @@ function ensureDir(dirPath) {
 
 function createChildEnv() {
   const cargoBin = path.join(os.homedir(), ".cargo", "bin");
-  const pathEntries = (process.env.PATH || "")
-    .split(path.delimiter)
-    .filter(Boolean);
-  if (!pathEntries.includes(cargoBin)) {
-    pathEntries.unshift(cargoBin);
-  }
-  return {
-    ...process.env,
-    PATH: pathEntries.join(path.delimiter)
-  };
+  const pathEntries = (process.env.PATH || "").split(path.delimiter).filter(Boolean);
+  if (!pathEntries.includes(cargoBin)) pathEntries.unshift(cargoBin);
+  return { ...process.env, PATH: pathEntries.join(path.delimiter) };
 }
 
 function runChecked(command, args, options = {}) {
-  const result = spawnSync(command, args, {
-    cwd: options.cwd,
-    env: {
-      ...CHILD_ENV,
-      ...(options.env || {})
-    },
-    encoding: "utf8",
-    stdio: ["ignore", "pipe", "pipe"]
-  });
-  if (result.error && !options.allowFailure) {
-    throw result.error;
-  }
-  if (!options.allowFailure && result.status !== 0) {
-    const stderr = (result.stderr || "").trim();
-    throw new Error(
-      `${command} ${args.join(" ")} failed with exit code ${result.status}${stderr ? `\n${stderr}` : ""}`
-    );
-  }
+  const result = spawnSync(command, args, { cwd: options.cwd, env: { ...CHILD_ENV, ...(options.env || {}) }, encoding: "utf8" });
+  if (result.status !== 0) throw new Error(`${command} failed with code ${result.status}\n${result.stderr}`);
   return result;
 }
 
-module.exports = {
-  SUPPORTED_CODEX_VERSIONS,
-  artifactPlatformKey,
-  installSlopex,
-  printStatus,
-  releaseArtifactName,
-  releaseArtifactUrl,
-  uninstallSlopex
-};
+function assertSupportedCodexVersion(version) {
+  if (!SUPPORTED_CODEX_VERSIONS.includes(version)) throw new Error(`Codex ${version} not supported.`);
+}
+
+module.exports = { installSlopex, printStatus, uninstallSlopex };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sloppydisk",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "Minimal reset-based continuity patcher for OpenAI Codex.",
   "license": "MIT",
   "type": "commonjs",
@@ -10,20 +10,12 @@
   "files": [
     "bin",
     "lib",
-    "README.md",
-    "LICENSE"
+    "patches"
   ],
   "scripts": {
-    "postinstall": "node bin/sloppydisk.js patch --postinstall",
-    "build-release-artifact": "node scripts/build-release-artifact.cjs",
-    "smoke:packaged": "node scripts/smoke-packaged-install.cjs"
-  },
-  "publishConfig": {
-    "access": "public"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/lmtlssss/slopex.git"
+    "patch": "node bin/sloppydisk.js patch",
+    "status": "node bin/sloppydisk.js status",
+    "unpatch": "node bin/sloppydisk.js unpatch"
   },
   "keywords": [
     "codex",