@scottzx/1agents 20260601.1.0

package/README.md

@@ -0,0 +1,38 @@
+# @scottzx/1agents
+
+随时随地，通过浏览器远程访问你的 AI 智能体和开发工作台。
+
+Remote Agent 是一个基于 Web 的远程工作台平台，让你打破必须在电脑前才能与 AI 交互的限制。它集成了终端访问、文件管理、Git 操作等功能，只需一个浏览器就能从任何地方连接到你的工作环境，继续对话、编辑代码、管理文件、查看仓库状态 —— 就像你正坐在它面前一样。
+
+终端与通信能力基于 [ttyd](https://github.com/tsl0922/ttyd) 和 [cc-connect](https://github.com/scottzx/cc-connect) 构建。
+
+## 安装
+
+你可以通过 npm 全局安装 `1agents`：
+
+```bash
+npm install -g @scottzx/1agents
+```
+
+安装脚本会自动检测您的操作系统和架构，并从 GitHub Releases 自动下载对应的预编译二进制包（包含 `1agent`、`ttyd` 静态程序和前端 Web 静态资源）。
+
+## 使用
+
+```bash
+# 启动远程工作台服务（默认端口 :8080）
+1agent
+
+# 指定监听端口和工作目录
+1agent -listen :9000 -workdir /path/to/your/workspace
+```
+
+启动后，在浏览器中打开 `http://localhost:8080` (或对应的监听端口) 即可访问完整的工作台。
+
+## 常用参数
+
+- `-listen string`：服务对外监听地址（默认 `":8080"`）
+- `-workdir string`：工作台暴露的文件系统根目录（默认 `"~"`）
+- `-tmux-session string`：用于终端持久化的 tmux会话名称（默认 `"1agents"`）
+- `-no-ttyd`：跳过启动内嵌的 ttyd 进程
+
+更多详情与文档请参考 GitHub 仓库：https://github.com/scottzx/1Agents

package/cc-run.js

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+
+"use strict";
+
+const { execFileSync, execSync } = require("child_process");
+const path = require("path");
+const fs = require("fs");
+
+const packageDir = __dirname;
+const myBinDir = path.join(packageDir, "bin");
+const ext = process.platform === "win32" ? ".exe" : "";
+let ccPath = path.join(myBinDir, "cc-connect" + ext);
+
+// ── Smart Compatibility: Delegate to standalone global cc-connect if it is newer/installed ──
+try {
+  const globalPrefix = execSync("npm config get prefix", { encoding: "utf8" }).trim();
+  const standaloneCCPath = process.platform === "win32"
+    ? path.join(globalPrefix, "node_modules", "cc-connect", "bin", "cc-connect.exe")
+    : path.join(globalPrefix, "lib", "node_modules", "cc-connect", "bin", "cc-connect");
+
+  if (fs.existsSync(standaloneCCPath)) {
+    // If standalone global cc-connect exists, use it to ensure absolute consistency and latest version
+    ccPath = standaloneCCPath;
+  }
+} catch (e) {
+  // Silent fallback to our bundled binary if detection fails or throws
+}
+
+// ── Fallback Execution ──
+if (!fs.existsSync(ccPath)) {
+  console.log(`[1agent] cc-connect CLI binary missing, running installer...`);
+  try {
+    execSync("node " + JSON.stringify(path.join(packageDir, "install.js")), {
+      stdio: "inherit",
+      cwd: packageDir,
+    });
+  } catch (err) {
+    console.error("[1agent] Auto-install failed. Please run manually: npm rebuild");
+    process.exit(1);
+  }
+}
+
+try {
+  execFileSync(ccPath, process.argv.slice(2), { stdio: "inherit" });
+} catch (err) {
+  process.exit(err.status || 1);
+}

package/install.js

@@ -0,0 +1,193 @@
+#!/usr/bin/env node
+
+"use strict";
+
+const { execSync } = require("child_process");
+const fs = require("fs");
+const path = require("path");
+const https = require("https");
+const http = require("http");
+
+const PACKAGE = require("./package.json");
+
+// Map NPM version (e.g. 20260523.1.0) back to Git Tag (e.g. v20260523-1)
+const versionParts = PACKAGE.version.split(".");
+if (versionParts.length < 2) {
+  throw new Error(`[1agent] Invalid package version: ${PACKAGE.version}`);
+}
+const VERSION = `v${versionParts[0]}-${versionParts[1]}`;
+const NAME = "1agents";
+
+const GITHUB_REPO = "scottzx/1Agents";
+
+const PLATFORM_MAP = {
+  darwin: "darwin",
+  linux: "linux",
+  win32: "windows",
+};
+
+const ARCH_MAP = {
+  x64: "amd64",
+  arm64: "arm64",
+};
+
+function getPlatformInfo() {
+  const platform = PLATFORM_MAP[process.platform];
+  const arch = ARCH_MAP[process.arch];
+  if (!platform || !arch) {
+    throw new Error(
+      `Unsupported platform: ${process.platform}/${process.arch}. ` +
+        `Supported: linux/darwin/windows x64/arm64`
+    );
+  }
+  const ext = platform === "windows" ? ".zip" : ".tar.gz";
+  const filename = `${NAME}-${VERSION}-${platform}-${arch}${ext}`;
+  return { platform, arch, ext, filename };
+}
+
+function getDownloadURLs(filename) {
+  return [
+    `https://github.com/${GITHUB_REPO}/releases/download/${VERSION}/${filename}`,
+  ];
+}
+
+function fetch(url, redirects = 5) {
+  return new Promise((resolve, reject) => {
+    if (redirects <= 0) return reject(new Error("Too many redirects"));
+    const mod = url.startsWith("https") ? https : http;
+    mod
+      .get(url, { headers: { "User-Agent": "1agent-npm" } }, (res) => {
+        if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+          return resolve(fetch(res.headers.location, redirects - 1));
+        }
+        if (res.statusCode !== 200) {
+          res.resume();
+          return reject(new Error(`HTTP ${res.statusCode} for ${url}`));
+        }
+        const chunks = [];
+        res.on("data", (c) => chunks.push(c));
+        res.on("end", () => resolve(Buffer.concat(chunks)));
+        res.on("error", reject);
+      })
+      .on("error", reject);
+  });
+}
+
+async function download(urls) {
+  for (const url of urls) {
+    try {
+      console.log(`[1agent] Downloading from ${url}`);
+      const data = await fetch(url);
+      console.log(`[1agent] Downloaded ${(data.length / 1024 / 1024).toFixed(2)} MB`);
+      return data;
+    } catch (err) {
+      console.warn(`[1agent] Failed: ${err.message}, trying next source...`);
+    }
+  }
+  throw new Error(
+    `[1agent] Could not download binary from any source.\n` +
+      `  Tried: ${urls.join(", ")}\n` +
+      `  You can download manually from https://github.com/${GITHUB_REPO}/releases`
+  );
+}
+
+function extractTarGz(buffer, destDir) {
+  const tmpFile = path.join(destDir, "_tmp.tar.gz");
+  fs.writeFileSync(tmpFile, buffer);
+  try {
+    execSync(`tar xzf "${tmpFile}" -C "${destDir}"`, { stdio: "pipe" });
+  } finally {
+    try {
+      fs.unlinkSync(tmpFile);
+    } catch {}
+  }
+}
+
+function extractZip(buffer, destDir) {
+  const tmpFile = path.join(destDir, "_tmp.zip");
+  fs.writeFileSync(tmpFile, buffer);
+  try {
+    try {
+      execSync(`unzip -o "${tmpFile}" -d "${destDir}"`, { stdio: "pipe" });
+    } catch {
+      execSync(`powershell -Command "Expand-Archive -Force '${tmpFile}' '${destDir}'"`, {
+        stdio: "pipe",
+      });
+    }
+  } finally {
+    try {
+      fs.unlinkSync(tmpFile);
+    } catch {}
+  }
+}
+
+async function main() {
+  const { platform, arch, ext, filename } = getPlatformInfo();
+  console.log(`[1agent] Platform: ${platform}/${arch}`);
+
+  const packageDir = __dirname;
+  const binDir = path.join(packageDir, "bin");
+  const extSuffix = platform === "windows" ? ".exe" : "";
+  const agentPath = path.join(binDir, NAME + extSuffix);
+  const ttydPath = path.join(binDir, "ttyd" + extSuffix);
+
+  // Check if binaries already exist and match version
+  if (fs.existsSync(agentPath) && fs.existsSync(ttydPath)) {
+    console.log(`[1agent] Binaries already exist in ${binDir}. Replacing with ${VERSION}...`);
+    try {
+      fs.unlinkSync(agentPath);
+      fs.unlinkSync(ttydPath);
+    } catch (err) {
+      // Ignore if they can't be deleted, we will overwrite
+    }
+  }
+
+  // Create bin and dist directory structure just in case
+  fs.mkdirSync(binDir, { recursive: true });
+
+  const urls = getDownloadURLs(filename);
+  const data = await download(urls);
+
+  console.log(`[1agent] Extracting files into ${packageDir}...`);
+  if (ext === ".tar.gz") {
+    extractTarGz(data, packageDir);
+  } else {
+    extractZip(data, packageDir);
+  }
+
+  // Make binaries executable on Darwin and Linux
+  if (platform !== "windows") {
+    if (fs.existsSync(agentPath)) {
+      fs.chmodSync(agentPath, 0o755);
+    }
+    if (fs.existsSync(ttydPath)) {
+      fs.chmodSync(ttydPath, 0o755);
+    }
+  }
+
+  // Darwin Quarantine Attribute Removal
+  if (platform === "darwin") {
+    try {
+      if (fs.existsSync(agentPath)) {
+        execSync(`xattr -d com.apple.quarantine "${agentPath}"`, { stdio: "pipe" });
+      }
+      if (fs.existsSync(ttydPath)) {
+        execSync(`xattr -d com.apple.quarantine "${ttydPath}"`, { stdio: "pipe" });
+      }
+      console.log(`[1agent] Removed macOS quarantine attribute`);
+    } catch {
+      // xattr fails if attribute doesn't exist, which is fine
+    }
+  }
+
+  console.log(`[1agent] Successfully installed to ${packageDir}`);
+}
+
+main().catch((err) => {
+  console.error(err.message);
+  console.error(
+    "[1agent] Installation failed. You can install manually:\n" +
+      `  https://github.com/${GITHUB_REPO}/releases/tag/${VERSION}`
+  );
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@scottzx/1agents",
+  "version": "20260601.1.0",
+  "description": "Browser-based remote workbench integrating terminal access, file management, and AI agent communication",
+  "keywords": [
+    "1agent",
+    "terminal",
+    "xterm",
+    "ttyd",
+    "file-manager",
+    "ai-agent",
+    "workbench"
+  ],
+  "homepage": "https://github.com/scottzx/1Agents",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/scottzx/1Agents.git"
+  },
+  "license": "MIT",
+  "author": "scottzx",
+  "bin": {
+    "1agents": "run.js",
+    "cc-connect": "cc-run.js"
+  },
+  "scripts": {
+    "postinstall": "node install.js"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "files": [
+    "install.js",
+    "run.js",
+    "cc-run.js",
+    "README.md"
+  ]
+}

package/run.js

@@ -0,0 +1,307 @@
+#!/usr/bin/env node
+
+"use strict";
+
+const { execFileSync, execSync, spawn } = require("child_process");
+const path = require("path");
+const fs = require("fs");
+const os = require("os");
+
+const PACKAGE = require("./package.json");
+const NAME = "1agents";
+const packageDir = __dirname;
+const binDir = path.join(packageDir, "bin");
+const ext = process.platform === "win32" ? ".exe" : "";
+const agentPath = path.join(binDir, NAME + ext);
+const ttydPath = path.join(binDir, "ttyd" + ext);
+
+function needsInstall() {
+  if (!fs.existsSync(agentPath)) return true;
+  if (!fs.existsSync(ttydPath)) return true;
+  return false;
+}
+
+if (needsInstall()) {
+  console.log(`[1agent] Binaries missing, running installer...`);
+  try {
+    execSync("node " + JSON.stringify(path.join(packageDir, "install.js")), {
+      stdio: "inherit",
+      cwd: packageDir,
+    });
+  } catch (err) {
+    console.error("[1agent] Auto-install failed. Please run manually: npm rebuild");
+    process.exit(1);
+  }
+}
+
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+async function main() {
+  const userArgs = process.argv.slice(2);
+  const command = userArgs[0];
+
+  const daemonDir = path.join(os.homedir(), ".1agents");
+  const daemonJson = path.join(daemonDir, "daemon.json");
+  const logFile = path.join(daemonDir, "1agents.log");
+
+  const isDaemonCommand = ["start", "stop", "status", "logs"].includes(command);
+
+  if (isDaemonCommand) {
+    if (command === "start") {
+      let isRunning = false;
+      let existingPid = null;
+      let existingAddr = "";
+      try {
+        if (fs.existsSync(daemonJson)) {
+          const info = JSON.parse(fs.readFileSync(daemonJson, "utf8"));
+          existingPid = info.pid;
+          existingAddr = info.listen_addr;
+          if (existingPid) {
+            process.kill(existingPid, 0);
+            isRunning = true;
+          }
+        }
+      } catch (e) {
+        isRunning = false;
+      }
+
+      if (isRunning) {
+        console.log(`⚠️ 1agents is already running in the background (PID: ${existingPid}) on ${existingAddr}.`);
+        process.exit(0);
+      }
+
+      // Prepare arguments
+      const finalArgs = [];
+      if (!userArgs.some(arg => arg.startsWith("-ttyd-bin"))) {
+        finalArgs.push("-ttyd-bin", ttydPath);
+      }
+      if (!userArgs.some(arg => arg.startsWith("-static"))) {
+        const staticPath = path.join(packageDir, "dist");
+        finalArgs.push("-static", staticPath);
+      }
+      // Add all original arguments except 'start'
+      finalArgs.push(...userArgs.slice(1));
+
+      if (!fs.existsSync(daemonDir)) {
+        fs.mkdirSync(daemonDir, { recursive: true });
+      }
+
+      console.log("Starting 1agents in the background...");
+      const logStream = fs.openSync(logFile, "a");
+      const child = spawn(agentPath, finalArgs, {
+        detached: true,
+        stdio: ["ignore", logStream, logStream]
+      });
+      child.unref();
+
+      // Wait for the Go binary to boot and write its daemon.json
+      let started = false;
+      let pid = child.pid;
+      let listenAddr = "";
+
+      for (let i = 0; i < 20; i++) {
+        await sleep(200);
+        try {
+          process.kill(child.pid, 0);
+        } catch (e) {
+          break; // Exited early
+        }
+
+        try {
+          if (fs.existsSync(daemonJson)) {
+            const info = JSON.parse(fs.readFileSync(daemonJson, "utf8"));
+            if (info.pid === child.pid || process.platform === "win32") {
+              pid = info.pid || child.pid;
+              listenAddr = info.listen_addr;
+              started = true;
+              break;
+            }
+          }
+        } catch (e) {}
+      }
+
+      if (!started) {
+        console.error("❌ Failed to start 1agents in the background.");
+        try {
+          if (fs.existsSync(logFile)) {
+            const logs = fs.readFileSync(logFile, "utf8").split("\n").slice(-15).join("\n");
+            console.error("\nLast 15 lines of log:\n" + logs);
+          }
+        } catch (e) {}
+        process.exit(1);
+      }
+
+      console.log("\n==================================================================");
+      console.log("🚀 1agents started successfully in the background!");
+      console.log(`● PID         : ${pid}`);
+      console.log(`● Local Port  : ${listenAddr}`);
+      console.log(`● Log File    : ${logFile}`);
+      console.log("==================================================================");
+      console.log("Commands to manage the daemon:");
+      console.log("  1agents status   - Check running status");
+      console.log("  1agents logs -f  - Follow log output");
+      console.log("  1agents stop     - Stop the background server\n");
+      process.exit(0);
+    }
+
+    else if (command === "stop") {
+      let pid = null;
+      try {
+        if (fs.existsSync(daemonJson)) {
+          const info = JSON.parse(fs.readFileSync(daemonJson, "utf8"));
+          pid = info.pid;
+        }
+      } catch (e) {}
+
+      if (!pid) {
+        console.log("1agents is not running (no active daemon found).");
+        process.exit(0);
+      }
+
+      let isAlive = false;
+      try {
+        process.kill(pid, 0);
+        isAlive = true;
+      } catch (e) {}
+
+      if (!isAlive) {
+        console.log("1agents is not running (PID not active). Cleaning up...");
+        try { fs.unlinkSync(daemonJson); } catch (e) {}
+        process.exit(0);
+      }
+
+      console.log(`Stopping 1agents (PID: ${pid})...`);
+      try {
+        process.kill(pid, "SIGTERM");
+      } catch (e) {
+        console.error(`Failed to send SIGTERM: ${e.message}`);
+      }
+
+      let stopped = false;
+      for (let i = 0; i < 25; i++) {
+        await sleep(200);
+        try {
+          process.kill(pid, 0);
+        } catch (e) {
+          stopped = true;
+          break;
+        }
+      }
+
+      if (!stopped) {
+        console.log("Process did not stop gracefully. Sending SIGKILL...");
+        try {
+          process.kill(pid, "SIGKILL");
+        } catch (e) {}
+      }
+
+      try { fs.unlinkSync(daemonJson); } catch (e) {}
+      console.log("❇️ 1agents stopped successfully.");
+      process.exit(0);
+    }
+
+    else if (command === "status") {
+      let isRunning = false;
+      let pid = null;
+      let listenAddr = "";
+      let mtime = null;
+      try {
+        if (fs.existsSync(daemonJson)) {
+          const stats = fs.statSync(daemonJson);
+          mtime = stats.mtime;
+          const info = JSON.parse(fs.readFileSync(daemonJson, "utf8"));
+          pid = info.pid;
+          listenAddr = info.listen_addr;
+          if (pid) {
+            process.kill(pid, 0);
+            isRunning = true;
+          }
+        }
+      } catch (e) {
+        isRunning = false;
+      }
+
+      if (isRunning) {
+        console.log("\n1agents daemon status:");
+        console.log(`● Active     : running (since ${mtime ? mtime.toLocaleString() : "unknown"})`);
+        console.log(`● PID        : ${pid}`);
+        console.log(`● Address    : ${listenAddr}`);
+        console.log(`● Log File   : ${logFile}`);
+
+        console.log();
+      } else {
+        if (fs.existsSync(daemonJson)) {
+          console.log("● Status     : stopped (stale PID file found)");
+          try {
+            fs.unlinkSync(daemonJson);
+          } catch (e) {}
+        } else {
+          console.log("● Status     : stopped");
+        }
+      }
+      process.exit(0);
+    }
+
+    else if (command === "logs") {
+      const follow = userArgs.includes("-f") || userArgs.includes("--follow");
+      let numLines = 50;
+
+      const nIndex = userArgs.findIndex(arg => arg === "-n");
+      if (nIndex !== -1 && nIndex + 1 < userArgs.length) {
+        const val = parseInt(userArgs[nIndex + 1], 10);
+        if (!isNaN(val) && val > 0) {
+          numLines = val;
+        }
+      }
+
+      if (!fs.existsSync(logFile)) {
+        console.log("No log file found.");
+        process.exit(0);
+      }
+
+      const data = fs.readFileSync(logFile, "utf8");
+      const lines = data.split("\n");
+      const lastLines = lines.slice(-numLines).join("\n");
+      console.log(lastLines);
+
+      if (follow) {
+        fs.watchFile(logFile, { interval: 250 }, (curr, prev) => {
+          if (curr.mtime <= prev.mtime) return;
+          if (curr.size <= prev.size) return;
+          try {
+            const fd = fs.openSync(logFile, "r");
+            const buffer = Buffer.alloc(curr.size - prev.size);
+            fs.readSync(fd, buffer, 0, buffer.length, prev.size);
+            fs.closeSync(fd);
+            process.stdout.write(buffer.toString());
+          } catch (e) {}
+        });
+
+        await new Promise(() => {}); // Keep alive
+      }
+      process.exit(0);
+    }
+  } else {
+    // Foreground run (default)
+    const finalArgs = [];
+    if (!userArgs.some(arg => arg.startsWith("-ttyd-bin"))) {
+      finalArgs.push("-ttyd-bin", ttydPath);
+    }
+    if (!userArgs.some(arg => arg.startsWith("-static"))) {
+      const staticPath = path.join(packageDir, "dist");
+      finalArgs.push("-static", staticPath);
+    }
+    finalArgs.push(...userArgs);
+
+    try {
+      execFileSync(agentPath, finalArgs, { stdio: "inherit" });
+    } catch (err) {
+      process.exit(err.status || 1);
+    }
+  }
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});