@j-ho/agents-office 0.1.2

package/README.md

@@ -0,0 +1,115 @@
+# Agents Office
+
+Claude Code가 작업하는 과정을 **사무실 속 에이전트(Researcher/Coder/Reviewer/Manager)**로 시각화하는 Tauri 데스크톱 앱입니다.  
+로컬의 Claude 로그(`$HOME/.claude/**`)를 감시(watch)하고, 이벤트를 프론트엔드(PixiJS 캔버스 + Inbox 로그 패널)로 스트리밍합니다.
+
+![Agents Office screenshot](./image.png)
+
+## 주요 기능
+- **에이전트 시각화**: 상태(Idle/Working/Thinking/Passing/Error)를 픽셀 아트 스타일로 표시
+- **Inbox 로그**: Claude 로그 라인을 `LogEntry`로 파싱해 최근 항목을 표시(최대 100개)
+- **Watcher 상태 표시**: `Watching/Idle`, 세션 ID 표시(이벤트 기반)
+
+## 요구사항
+- **Node.js**: 18 이상 권장
+- **Rust**: stable toolchain
+- **Tauri prerequisites**: OS별 빌드 의존성 설치가 필요합니다. 자세한 내용은 [Tauri prerequisites](https://tauri.app/start/prerequisites/)를 참고하세요.
+
+## 실행 방법
+
+### 0) npx로 바로 실행 (macOS, 권장)
+
+로컬에 Rust/Tauri 툴체인 없이도 아래 명령으로 앱을 실행할 수 있습니다.  
+실제 앱 바이너리는 GitHub Releases에서 다운로드되며, 한 번 다운로드되면 캐시에 저장되어 다음 실행은 빨라집니다.
+
+```bash
+npx @j-ho/agents-office
+```
+
+- **버전 고정 실행**:
+
+```bash
+npx @j-ho/agents-office --version 0.1.2
+```
+
+- **캐시 강제 갱신**:
+
+```bash
+npx @j-ho/agents-office --force
+```
+
+#### Gatekeeper 주의사항 (macOS)
+다운로드된 앱이 차단되면 **System Settings → Privacy & Security**에서 “Open Anyway(또는 허용)”를 선택해야 할 수 있습니다.
+
+### 1) 의존성 설치
+
+```bash
+npm install
+```
+
+### 2) 웹(브라우저)로 개발 실행
+
+```bash
+npm run dev
+```
+
+### 3) 데스크톱(Tauri)로 개발 실행
+
+```bash
+npm run tauri:dev
+```
+
+## 빌드
+
+### 웹 빌드
+
+```bash
+npm run build
+```
+
+### 데스크톱(Tauri) 빌드
+
+```bash
+npm run tauri:build
+```
+
+## 권한/보안 (중요)
+이 앱은 Claude 로그를 읽기 위해 Tauri capability로 **로컬 파일 읽기 권한**을 사용합니다.
+
+- **읽는 경로**: `$HOME/.claude/**`
+  - 주로 `$HOME/.claude/debug`, `$HOME/.claude/projects` 하위를 감시합니다.
+- **읽는 파일 유형**: `.txt`, `.jsonl`, `.json`
+- **동작 방식**: 파일의 “새로 추가된 줄”만 읽어 프론트로 이벤트를 emit 합니다.
+- **주의**: 로그에 민감 정보가 포함될 수 있습니다. 앱은 로컬에서만 처리하지만, 화면 공유/스크린샷에 포함되지 않도록 주의하세요.
+
+관련 설정은 [`src-tauri/capabilities/default.json`](./src-tauri/capabilities/default.json)에서 확인할 수 있습니다.
+
+## 아키텍처 개요
+
+```mermaid
+flowchart LR
+  claudeHome[claudeHomeDir] --> debugDir[debugDir]
+  claudeHome --> projectsDir[projectsDir]
+  watcher[logWatcherRust] -->|"emit(app-event)"| frontend[reactPxiUi]
+  frontend --> stores[zustandStores]
+```
+
+### 이벤트 흐름(요약)
+- Rust 워처가 파일 변경을 감지하고 로그 라인을 파싱
+- `app-event`로 프론트에 이벤트 전송
+  - `LogEntry`: Inbox 로그 추가
+  - `AgentUpdate`: 에이전트 상태/업무 표시 갱신
+  - `WatcherStatus`: 상단 상태(Watching/Idle) 갱신
+
+## 릴리스 자산 규격 (npx 실행용)
+`npx @j-ho/agents-office`는 GitHub Releases(`awesomelon/agents-office`)에서 macOS 빌드 산출물을 다운로드합니다.
+
+- **태그 규칙**: `vX.Y.Z` (예: `v0.1.2`)
+- **권장 자산 이름**: `Agents-Office-macos.zip`
+  - zip 내부에 `Agents Office.app/` 번들이 포함되어 있어야 합니다.
+- (선택) 무결성 검증:
+  - `Agents-Office-macos.zip.sha256` 또는 `checksums.txt`를 함께 업로드하면 CLI가 sha256 검증을 수행합니다.
+
+## 라이선스
+MIT
+

package/cli/agents-office.mjs

@@ -0,0 +1,370 @@
+#!/usr/bin/env node
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import crypto from "node:crypto";
+import https from "node:https";
+import { spawnSync } from "node:child_process";
+
+const GITHUB_OWNER = "awesomelon";
+const GITHUB_REPO = "agents-office";
+const USER_AGENT = "agents-office-cli";
+
+const CACHE_DIR = process.env.AGENTS_OFFICE_CACHE_DIR
+  ? path.resolve(process.env.AGENTS_OFFICE_CACHE_DIR)
+  : path.join(os.homedir(), "Library", "Caches", "agents-office");
+
+const ASSET_NAME_CANDIDATES = [
+  "Agents-Office-macos.zip",
+  "Agents Office-macos.zip",
+  "AgentsOffice-macos.zip",
+  "Agents-Office-macOS.zip",
+  "Agents Office.app.zip",
+];
+
+function parseArgs(argv) {
+  const args = { version: null, help: false, force: false, quiet: false };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--help" || a === "-h") args.help = true;
+    else if (a === "--quiet" || a === "-q") args.quiet = true;
+    else if (a === "--force") args.force = true;
+    else if (a === "--version" || a === "-v") args.version = argv[++i] ?? null;
+  }
+  return args;
+}
+
+function log(msg, { quiet }) {
+  if (!quiet) process.stdout.write(`${msg}\n`);
+}
+
+function fail(msg) {
+  process.stderr.write(`${msg}\n`);
+  process.exit(1);
+}
+
+function usage() {
+  return `
+Usage:
+  npx @j-ho/agents-office [--version <x.y.z>] [--force] [--quiet]
+
+Options:
+  --version, -v   Use a specific version tag (e.g. 0.1.2 -> v0.1.2)
+  --force         Re-download even if cached
+  --quiet, -q     Reduce logs
+  --help, -h      Show help
+`;
+}
+
+function ensureDir(dirPath) {
+  fs.mkdirSync(dirPath, { recursive: true });
+}
+
+function withLock(lockPath, fn) {
+  const started = Date.now();
+  const timeoutMs = 60_000;
+  while (true) {
+    try {
+      const fd = fs.openSync(lockPath, "wx");
+      try {
+        return fn();
+      } finally {
+        try {
+          fs.closeSync(fd);
+        } catch {}
+        try {
+          fs.unlinkSync(lockPath);
+        } catch {}
+      }
+    } catch (err) {
+      if (err && err.code !== "EEXIST") throw err;
+      if (Date.now() - started > timeoutMs) {
+        fail(`Another agents-office process is busy (lock timeout): ${lockPath}`);
+      }
+      // simple backoff
+      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 250);
+    }
+  }
+}
+
+function httpsGetJson(url) {
+  return new Promise((resolve, reject) => {
+    const req = https.request(
+      url,
+      {
+        method: "GET",
+        headers: {
+          "User-Agent": USER_AGENT,
+          Accept: "application/vnd.github+json",
+        },
+      },
+      (res) => {
+        let body = "";
+        res.setEncoding("utf8");
+        res.on("data", (chunk) => (body += chunk));
+        res.on("end", () => {
+          if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
+            try {
+              resolve(JSON.parse(body));
+            } catch (e) {
+              reject(new Error(`Failed to parse JSON from ${url}: ${e.message}`));
+            }
+          } else {
+            reject(new Error(`HTTP ${res.statusCode} from ${url}: ${body.slice(0, 200)}`));
+          }
+        });
+      }
+    );
+    req.on("error", reject);
+    req.end();
+  });
+}
+
+function downloadToFile(url, destPath, { quiet }) {
+  return new Promise((resolve, reject) => {
+    ensureDir(path.dirname(destPath));
+    const tmpPath = `${destPath}.tmp-${process.pid}`;
+    const file = fs.createWriteStream(tmpPath);
+
+    const req = https.request(
+      url,
+      {
+        method: "GET",
+        headers: {
+          "User-Agent": USER_AGENT,
+          Accept: "application/octet-stream",
+        },
+      },
+      (res) => {
+        if (res.statusCode && res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+          file.close(() => {
+            fs.rmSync(tmpPath, { force: true });
+            resolve(downloadToFile(res.headers.location, destPath, { quiet }));
+          });
+          return;
+        }
+
+        if (!res.statusCode || res.statusCode < 200 || res.statusCode >= 300) {
+          file.close(() => {
+            fs.rmSync(tmpPath, { force: true });
+            reject(new Error(`Download failed: HTTP ${res.statusCode} ${url}`));
+          });
+          return;
+        }
+
+        res.pipe(file);
+        file.on("finish", () => {
+          file.close(() => {
+            fs.renameSync(tmpPath, destPath);
+            log(`Downloaded: ${path.basename(destPath)}`, { quiet });
+            resolve();
+          });
+        });
+      }
+    );
+
+    req.on("error", (err) => {
+      try {
+        file.close(() => fs.rmSync(tmpPath, { force: true }));
+      } catch {}
+      reject(err);
+    });
+    file.on("error", (err) => {
+      try {
+        fs.rmSync(tmpPath, { force: true });
+      } catch {}
+      reject(err);
+    });
+
+    req.end();
+  });
+}
+
+function sha256File(filePath) {
+  const hash = crypto.createHash("sha256");
+  const buf = fs.readFileSync(filePath);
+  hash.update(buf);
+  return hash.digest("hex");
+}
+
+function extractZip(zipPath, outDir) {
+  ensureDir(outDir);
+  // Use macOS built-in ditto for zip extraction.
+  const r = spawnSync("ditto", ["-x", "-k", zipPath, outDir], { stdio: "inherit" });
+  if (r.status !== 0) {
+    throw new Error(`Failed to extract zip (ditto exit ${r.status})`);
+  }
+}
+
+function findAppBundle(dirPath, maxDepth = 5) {
+  if (maxDepth < 0) return null;
+  const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+  for (const ent of entries) {
+    const full = path.join(dirPath, ent.name);
+    if (ent.isDirectory() && ent.name.endsWith(".app")) return full;
+  }
+  for (const ent of entries) {
+    const full = path.join(dirPath, ent.name);
+    if (ent.isDirectory() && !ent.name.endsWith(".app")) {
+      const found = findAppBundle(full, maxDepth - 1);
+      if (found) return found;
+    }
+  }
+  return null;
+}
+
+function openApp(appPath) {
+  const r = spawnSync("open", [appPath], { stdio: "inherit" });
+  return r.status ?? 1;
+}
+
+async function resolveReleaseTag(requestedVersion) {
+  if (requestedVersion) {
+    const v = requestedVersion.startsWith("v") ? requestedVersion.slice(1) : requestedVersion;
+    return `v${v}`;
+  }
+  const latest = await httpsGetJson(`https://api.github.com/repos/${GITHUB_OWNER}/${GITHUB_REPO}/releases/latest`);
+  if (!latest?.tag_name) throw new Error("GitHub latest release has no tag_name");
+  return latest.tag_name;
+}
+
+async function fetchReleaseByTag(tag) {
+  return await httpsGetJson(`https://api.github.com/repos/${GITHUB_OWNER}/${GITHUB_REPO}/releases/tags/${encodeURIComponent(tag)}`);
+}
+
+function pickAsset(release) {
+  const assets = Array.isArray(release.assets) ? release.assets : [];
+  for (const name of ASSET_NAME_CANDIDATES) {
+    const a = assets.find((x) => x && x.name === name);
+    if (a) return a;
+  }
+  // Fallback: any zip that looks like macos
+  const fallback = assets.find((a) => typeof a?.name === "string" && a.name.endsWith(".zip") && /mac/i.test(a.name));
+  return fallback ?? null;
+}
+
+function findChecksumAsset(release, zipAssetName) {
+  const assets = Array.isArray(release.assets) ? release.assets : [];
+  const direct = assets.find((a) => a?.name === `${zipAssetName}.sha256`);
+  if (direct) return { kind: "sha256", asset: direct };
+  const checksums = assets.find((a) => a?.name === "checksums.txt");
+  if (checksums) return { kind: "checksums.txt", asset: checksums };
+  return null;
+}
+
+async function downloadOptionalChecksum(release, zipAsset, cacheDir, { quiet }) {
+  const checksumInfo = findChecksumAsset(release, zipAsset.name);
+  if (!checksumInfo) return null;
+
+  const checksumPath = path.join(cacheDir, checksumInfo.asset.name);
+  await downloadToFile(checksumInfo.asset.browser_download_url, checksumPath, { quiet });
+
+  if (checksumInfo.kind === "sha256") {
+    const expected = fs.readFileSync(checksumPath, "utf8").trim().split(/\s+/)[0];
+    return { expected, source: checksumInfo.asset.name };
+  }
+
+  // checksums.txt: try to find a line containing the asset name
+  const text = fs.readFileSync(checksumPath, "utf8");
+  const line = text
+    .split("\n")
+    .map((l) => l.trim())
+    .find((l) => l && l.includes(zipAsset.name));
+  if (!line) return null;
+  const expected = line.split(/\s+/)[0];
+  return { expected, source: checksumInfo.asset.name };
+}
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  if (args.help) {
+    process.stdout.write(usage());
+    process.exit(0);
+  }
+
+  ensureDir(CACHE_DIR);
+  const lockPath = path.join(CACHE_DIR, "download.lock");
+
+  await withLock(lockPath, async () => {
+    const tag = await resolveReleaseTag(args.version);
+    const versionDir = path.join(CACHE_DIR, tag);
+    const extractDir = path.join(versionDir, "extract");
+    const marker = path.join(versionDir, ".ready");
+
+    log(`Agents Office CLI (tag: ${tag})`, args);
+
+    if (!args.force && fs.existsSync(marker)) {
+      const appPath = findAppBundle(extractDir);
+      if (!appPath) {
+        // cache seems broken; force re-download below
+        log("Cache marker exists but .app not found; re-downloading.", args);
+      } else {
+        log(`Using cache: ${appPath}`, args);
+        const code = openApp(appPath);
+        if (code !== 0) {
+          fail(
+            `Failed to open app (exit ${code}). If macOS Gatekeeper blocks it, allow it in System Settings -> Privacy & Security.`
+          );
+        }
+        return;
+      }
+    }
+
+    // Prepare fresh directory
+    fs.rmSync(versionDir, { recursive: true, force: true });
+    ensureDir(versionDir);
+    ensureDir(extractDir);
+
+    const release = await fetchReleaseByTag(tag);
+    const asset = pickAsset(release);
+    if (!asset?.browser_download_url || !asset?.name) {
+      fail(
+        `No suitable macOS zip asset found in release ${tag}.\nExpected one of: ${ASSET_NAME_CANDIDATES.join(
+          ", "
+        )}\nPlease upload a zip containing 'Agents Office.app/'.`
+      );
+    }
+
+    const zipPath = path.join(versionDir, asset.name);
+    log(`Downloading release asset: ${asset.name}`, args);
+    await downloadToFile(asset.browser_download_url, zipPath, args);
+
+    const checksum = await downloadOptionalChecksum(release, asset, versionDir, args);
+    if (checksum?.expected) {
+      const actual = sha256File(zipPath);
+      if (actual.toLowerCase() !== checksum.expected.toLowerCase()) {
+        fail(
+          `Checksum mismatch for ${asset.name}\nExpected(${checksum.source}): ${checksum.expected}\nActual: ${actual}`
+        );
+      }
+      log(`Checksum OK (${checksum.source})`, args);
+    } else {
+      log("Checksum: skipped (no checksum asset found)", args);
+    }
+
+    log("Extracting...", args);
+    extractZip(zipPath, extractDir);
+
+    const appPath = findAppBundle(extractDir);
+    if (!appPath) {
+      fail(
+        `Extraction completed but .app bundle not found.\nPlease ensure the zip contains 'Agents Office.app/' at any depth.`
+      );
+    }
+
+    fs.writeFileSync(marker, new Date().toISOString(), "utf8");
+    log(`Launching: ${appPath}`, args);
+    const code = openApp(appPath);
+    if (code !== 0) {
+      fail(
+        `Failed to open app (exit ${code}). If macOS Gatekeeper blocks it, allow it in System Settings -> Privacy & Security.`
+      );
+    }
+  });
+}
+
+main().catch((err) => {
+  const msg = err?.stack || err?.message || String(err);
+  fail(`[agents-office] ${msg}`);
+});
+

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@j-ho/agents-office",
+  "version": "0.1.2",
+  "description": "Claude Code visualization as agents working in an office",
+  "license": "MIT",
+  "author": "j-ho",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/awesomelon/agents-office.git"
+  },
+  "bugs": {
+    "url": "https://github.com/awesomelon/agents-office/issues"
+  },
+  "homepage": "https://github.com/awesomelon/agents-office#readme",
+  "keywords": [
+    "tauri",
+    "vite",
+    "react",
+    "pixijs",
+    "claude",
+    "visualization"
+  ],
+  "type": "module",
+  "bin": {
+    "agents-office": "./cli/agents-office.mjs"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "cli/"
+  ],
+  "scripts": {
+    "dev": "vite",
+    "build": "tsc && vite build",
+    "preview": "vite preview",
+    "tauri": "tauri",
+    "tauri:dev": "tauri dev",
+    "tauri:build": "tauri build"
+  },
+  "dependencies": {
+    "@pixi/react": "^7.1.2",
+    "@tauri-apps/api": "^2.1.1",
+    "@tauri-apps/plugin-fs": "^2.2.0",
+    "@tauri-apps/plugin-shell": "^2.2.0",
+    "pixi.js": "^7.4.2",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
+    "zustand": "^5.0.2"
+  },
+  "devDependencies": {
+    "@tauri-apps/cli": "^2.1.0",
+    "@types/react": "^18.3.12",
+    "@types/react-dom": "^18.3.1",
+    "@vitejs/plugin-react": "^4.3.4",
+    "autoprefixer": "^10.4.20",
+    "postcss": "^8.4.49",
+    "tailwindcss": "^3.4.16",
+    "typescript": "^5.7.2",
+    "vite": "^6.0.3"
+  }
+}