copilotoffice 1.0.0

package/README.md

@@ -0,0 +1,190 @@
+# Agency Office 🏢
+
+A 2D pixel-art RPG-style game where you walk around a virtual office and interact with AI agents. Each NPC runs a real Copilot CLI session with full coding capabilities — plan tasks, debug code, and orchestrate multi-agent workflows from inside a game.
+
+## Features
+
+- **Pixel-art office environment** — all sprites procedurally generated in code, no external image assets
+- **4 active NPC agents**, each with specialized capabilities:
+  - **Gene** (Generalist) — general-purpose coding, debugging, and research
+  - **Arthur** (Architect) — orchestrates plans and spins up agents for complex tasks
+  - **Dan** (Debugger) — bug investigation and root cause analysis
+  - **Alice** (Admin) — has direct access to edit this game's UI code (`workingDir: '.'`)
+- **6 reserve agent slots** — Azure, Val, Rex, Doc, Scout, and Penny have pre-generated sprites ready to activate
+- **Real terminal integration** via xterm.js — agents run actual Copilot CLI sessions through node-pty
+- **Multi-office management** — switch between projects with independent agent state per office
+- **Meeting Mode** — meet with Arthur in a private meeting room to plan and decompose complex tasks into structured subtasks
+- **Fleet execution** — parallel agent spawning for approved task plans
+- **Real-time status badges** — agent states (thinking, waiting, ready, slacking) with animated indicators
+- **Toast & OS notifications** — configurable per-event notifications for agent activity
+- **Session persistence** — terminal sessions and history survive restarts
+- **Player customization** — customizable character colors
+- **Mini-games** — Pong and Basketball (behind feature flags) for breaks
+- **Hot reload** development mode with file watching
+
+## Tech Stack
+
+- **Phaser 3** — 2D game framework (sole renderer)
+- **Electron 40+** — desktop app with Node.js integration
+- **TypeScript** — strict mode throughout
+- **esbuild** — fast bundling for game and Electron code
+- **xterm.js** — terminal emulator for agent conversations
+- **node-pty** — pseudo-terminal for running CLI processes
+
+## Getting Started
+
+### Prerequisites
+
+- Node.js 18+
+- npm
+
+### Install from npm (global command)
+
+```bash
+npm i -g copilotoffice
+copilotoffice
+```
+
+### Install from source (development)
+
+```bash
+cd AgencyOffice
+npm install
+
+# Build and run
+npm start
+
+# Development mode (with hot reload)
+npm run dev
+```
+
+### Controls
+
+| Key | Action |
+|-----|--------|
+| `WASD` / `Arrow Keys` | Move around the office |
+| `Shift` | Sprint (2x speed) |
+| `E` | Interact with nearby agent or object |
+| `F10` | Close terminal |
+| `Escape` | Close terminal or mini-game |
+| `Ctrl+Shift+N` | New terminal session |
+
+## Project Structure
+
+```
+AgencyOffice/
+├── electron/                    # Electron main process
+│   ├── main.ts                  # Window, IPC handlers, hot reload
+│   ├── cli-bridge.ts            # Mock/placeholder (not used at runtime)
+│   └── terminal/                # Terminal server subsystem
+│       ├── server.ts            # PTY owner (forked child process)
+│       ├── ipc-relay.ts         # IPC bridge (renderer ↔ main ↔ server)
+│       ├── preload.ts           # Context bridge (window.copilotBridge)
+│       ├── protocol.ts          # IPC message type definitions
+│       └── events-watcher.ts    # Copilot CLI event file parser
+├── src/                         # Renderer process (Phaser + DOM)
+│   ├── main.ts                  # Entry point — DOM layout, Phaser init, IPC wiring
+│   ├── index.html               # HTML host page
+│   ├── scenes/                  # Phaser scenes
+│   │   ├── BootScene.ts         # Procedural sprite generation
+│   │   ├── OfficeScene.ts       # Main game scene (layout, NPCs, interactions)
+│   │   └── MeetingScene.ts      # Meeting room with Arthur for planning
+│   ├── entities/                # Game entities
+│   │   ├── Player.ts            # Player character with movement
+│   │   └── NPC.ts               # NPC agents with status badges
+│   ├── sprites/                 # Procedural sprite generation
+│   │   ├── SpriteGenerator.ts   # Sprite sheet generation
+│   │   └── DirectionalSprite.ts # 4-direction animation utilities
+│   ├── ui/                      # UI overlays
+│   │   ├── TerminalOverlay.ts   # xterm.js terminal for agent sessions
+│   │   ├── FleetDashboard.ts    # Fleet execution dashboard
+│   │   ├── PongGame.ts          # Pong mini-game
+│   │   ├── BasketballGame.ts    # Basketball mini-game
+│   │   ├── ToastNotification.ts # Toast notification popups
+│   │   ├── NotificationService.ts
+│   │   ├── NotificationSettingsPanel.ts
+│   │   ├── CameraDragController.ts
+│   │   └── DialogBox.ts         # Legacy (deprecated)
+│   ├── input/                   # Keyboard focus management
+│   │   ├── InputManager.ts      # Central coordinator
+│   │   ├── GameInputListener.ts
+│   │   ├── GlobalInputListener.ts
+│   │   └── TerminalInputListener.ts
+│   ├── office/                  # Multi-office state management
+│   │   └── officeManager.ts     # Office CRUD, agent status tracking
+│   ├── meeting/                 # Meeting mode & fleet orchestration
+│   │   ├── types.ts             # MeetingPlan, TaskAssignment, FleetStatus
+│   │   ├── planParser.ts        # Terminal output → structured plan
+│   │   ├── planApproval.ts      # Plan review overlay
+│   │   ├── fleetOrchestrator.ts # Parallel agent spawning
+│   │   ├── fleetTracker.ts      # Fleet state machine
+│   │   └── fleetVisualizer.ts   # Fleet NPC visualization
+│   ├── layouts/                 # Layout system
+│   │   ├── types.ts             # DashboardRenderer, LayoutDefinition
+│   │   ├── index.ts             # Layout registry
+│   │   ├── default/             # Default office layout
+│   │   └── fleet/               # Fleet v-team layout
+│   └── config/                  # Static configuration
+│       ├── agents.ts            # Agent definitions & fleet config
+│       ├── depths.ts            # Phaser depth layer constants
+│       ├── notifications.ts     # Notification event settings
+│       ├── meetingPrompt.ts     # Meeting coordinator prompt
+│       └── playerCustomization.ts # Player color customization
+└── dist/                        # Build output
+```
+
+## Adding New Agents
+
+Edit `src/config/agents.ts` to add new NPCs. Six reserve agent slots (Azure, Val, Rex, Doc, Scout, Penny) already have pre-generated sprites — activate one by adding its config to the `AGENTS` array:
+
+```typescript
+{
+  id: 'unique-id',
+  name: 'Display Name',
+  skill: 'copilot-skill-name',
+  sprite: 'sprite_key',
+  color: 0xff0000,  // Hex color for procedural sprite
+  position: { x: 5, y: 7 },  // Grid position in office
+  greeting: "Hello message when player approaches",
+  description: 'Short description',
+  workingDir: 'optional/path',  // Optional custom working directory
+}
+```
+
+Sprites are auto-generated based on the color — no image assets needed.
+
+## Development
+
+```bash
+# Watch mode with hot reload
+npm run dev
+
+# Build only (no run)
+npm run build
+
+# Run without rebuilding
+npm run electron
+```
+
+## Release channels
+
+- **Stable**: `npm i -g copilotoffice` (uses npm `latest` dist-tag)
+- **Beta**: `npm i -g copilotoffice@beta` (uses npm `beta` dist-tag)
+
+For maintainers: pushing to GitHub is not enough for `npm i -g copilotoffice` by name.
+You must publish to npm. Typical flow:
+
+```bash
+npm run build
+npm test
+npm version patch
+npm publish
+
+# Beta example
+npm version prerelease --preid=beta
+npm publish --tag beta
+```
+
+## License
+
+ISC

package/bin/copilotoffice.js

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+
+const { spawn } = require('child_process');
+const path = require('path');
+
+function run() {
+  let electronBinary;
+  try {
+    electronBinary = require('electron');
+  } catch (error) {
+    console.error('[copilotoffice] Electron is not available. Try reinstalling the package.');
+    console.error(error);
+    process.exit(1);
+  }
+
+  const appRoot = path.resolve(__dirname, '..');
+  const child = spawn(electronBinary, [appRoot], {
+    stdio: 'inherit',
+    windowsHide: false,
+    env: {
+      ...process.env,
+      COPILOT_OFFICE_ENABLE_WATCHER: '0',
+      COPILOT_OFFICE_OPEN_DEVTOOLS: '0',
+      COPILOT_OFFICE_CLI_MODE: '1',
+    },
+  });
+
+  child.on('exit', (code) => {
+    process.exit(code ?? 0);
+  });
+
+  child.on('error', (error) => {
+    console.error('[copilotoffice] Failed to launch Electron.');
+    console.error(error);
+    process.exit(1);
+  });
+}
+
+run();

package/dist/electron/cli-bridge.js

@@ -0,0 +1,96 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// electron/cli-bridge.ts
+var cli_bridge_exports = {};
+__export(cli_bridge_exports, {
+  CLIBridge: () => CLIBridge
+});
+module.exports = __toCommonJS(cli_bridge_exports);
+var CLIBridge = class {
+  constructor() {
+    this.availableSkills = [
+      { name: "azure-prepare", description: "Prepare apps for Azure deployment" },
+      { name: "azure-validate", description: "Validate Azure deployment readiness" },
+      { name: "azure-deploy", description: "Deploy to Azure" },
+      { name: "azure-diagnostics", description: "Troubleshoot Azure issues" },
+      { name: "azure-resource-lookup", description: "Find Azure resources" },
+      { name: "azure-cost-optimization", description: "Optimize Azure costs" }
+    ];
+    console.log("CLI Bridge initialized");
+  }
+  getAvailableSkills() {
+    return this.availableSkills.map((s) => s.name);
+  }
+  async sendToSkill(skillName, message) {
+    return this.getMockResponse(skillName, message);
+  }
+  getMockResponse(skillName, message) {
+    const responses = {
+      "azure-prepare": [
+        "I can help you prepare your application for Azure! I'll analyze your project structure and generate the necessary infrastructure code.",
+        "Let me check your project... I can set up Bicep templates, azure.yaml, and Dockerfiles for deployment.",
+        "Ready to azurify your app! What kind of hosting do you need - Container Apps, App Service, or Functions?"
+      ],
+      "azure-validate": [
+        "I'll run validation checks on your Azure configuration. Give me a moment to inspect your setup...",
+        "Checking deployment readiness... Looking at your azure.yaml, Bicep files, and permissions.",
+        "Validation complete! Your configuration looks good. Ready to deploy when you are."
+      ],
+      "azure-deploy": [
+        "Deployment agent at your service! I can run `azd up` or `azd deploy` for you.",
+        "Ready to push to the cloud! Should I provision infrastructure first or just deploy code?",
+        "\u{1F680} Let's ship it! I'll handle the deployment pipeline for you."
+      ],
+      "azure-diagnostics": [
+        "Dr. Azure here! Tell me what's wrong and I'll help diagnose the issue.",
+        "I can analyze logs, check health probes, and troubleshoot common Azure problems.",
+        "What seems to be the trouble? Container not starting? Function timing out? Let's investigate."
+      ],
+      "azure-resource-lookup": [
+        "Scout reporting! I can find any Azure resources across your subscriptions.",
+        "Need to locate something? VMs, storage accounts, databases - I'll track it down.",
+        "Just tell me what you're looking for and I'll search your Azure environment."
+      ],
+      "azure-cost-optimization": [
+        "Accountant here! I specialize in finding cost savings in your Azure bill.",
+        "Let me analyze your spending... I'll find orphaned resources and rightsizing opportunities.",
+        "Money talk! I can identify unused resources and recommend cheaper alternatives."
+      ]
+    };
+    const skillResponses = responses[skillName] || [
+      `I'm the ${skillName} agent. How can I help you today?`,
+      `You asked about: "${message}". Let me think about that...`,
+      `Interesting question! As the ${skillName} specialist, I'd suggest...`
+    ];
+    return skillResponses[Math.floor(Math.random() * skillResponses.length)];
+  }
+  // Future: Real CLI integration
+  async spawnCLI(skillName, message) {
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        resolve(this.getMockResponse(skillName, message));
+      }, 1e3);
+    });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CLIBridge
+});

package/dist/electron/events-watcher.js

@@ -0,0 +1,198 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// electron/events-watcher.ts
+var events_watcher_exports = {};
+__export(events_watcher_exports, {
+  EventsWatcher: () => EventsWatcher,
+  formatToolStatus: () => formatToolStatus
+});
+module.exports = __toCommonJS(events_watcher_exports);
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var os = __toESM(require("os"));
+var EventsWatcher = class _EventsWatcher {
+  constructor(sessionId) {
+    this.fileOffset = 0;
+    this.lineBuffer = "";
+    this.watcher = null;
+    this.pollTimer = null;
+    this.fileExistsTimer = null;
+    this.callback = null;
+    this.stopped = false;
+    this.reading = false;
+    this.sessionId = sessionId;
+    this.filePath = path.join(
+      os.homedir(),
+      ".copilot",
+      "session-state",
+      sessionId,
+      "events.jsonl"
+    );
+  }
+  static {
+    this.POLL_INTERVAL_MS = 500;
+  }
+  static {
+    this.FILE_CHECK_INTERVAL_MS = 200;
+  }
+  static {
+    this.MAX_FILE_WAIT_MS = 6e4;
+  }
+  getSessionId() {
+    return this.sessionId;
+  }
+  getFilePath() {
+    return this.filePath;
+  }
+  start(onEvent) {
+    this.callback = onEvent;
+    this.stopped = false;
+    fs.promises.access(this.filePath, fs.constants.F_OK).then(() => this.startWatching()).catch(() => {
+      console.log(`[EventsWatcher] Waiting for events.jsonl: ${this.filePath}`);
+      const startTime = Date.now();
+      this.fileExistsTimer = setInterval(() => {
+        if (this.stopped) {
+          if (this.fileExistsTimer) clearInterval(this.fileExistsTimer);
+          return;
+        }
+        if (Date.now() - startTime > _EventsWatcher.MAX_FILE_WAIT_MS) {
+          console.warn(`[EventsWatcher] Timed out waiting for events.jsonl after ${_EventsWatcher.MAX_FILE_WAIT_MS / 1e3}s`);
+          if (this.fileExistsTimer) clearInterval(this.fileExistsTimer);
+          this.fileExistsTimer = null;
+          return;
+        }
+        fs.promises.access(this.filePath, fs.constants.F_OK).then(() => {
+          console.log(`[EventsWatcher] Found events.jsonl`);
+          if (this.fileExistsTimer) clearInterval(this.fileExistsTimer);
+          this.fileExistsTimer = null;
+          this.startWatching();
+        }).catch(() => {
+        });
+      }, _EventsWatcher.FILE_CHECK_INTERVAL_MS);
+    });
+  }
+  startWatching() {
+    this.readNewLines();
+    try {
+      this.watcher = fs.watch(this.filePath, () => {
+        if (!this.stopped) this.readNewLines();
+      });
+    } catch (e) {
+      console.log(`[EventsWatcher] fs.watch failed: ${e}`);
+    }
+    this.pollTimer = setInterval(() => {
+      if (!this.stopped) this.readNewLines();
+    }, _EventsWatcher.POLL_INTERVAL_MS);
+  }
+  async readNewLines() {
+    if (this.reading) return;
+    this.reading = true;
+    try {
+      const stat = await fs.promises.stat(this.filePath);
+      if (stat.size <= this.fileOffset) return;
+      const handle = await fs.promises.open(this.filePath, "r");
+      try {
+        const buf = Buffer.alloc(stat.size - this.fileOffset);
+        await handle.read(buf, 0, buf.length, this.fileOffset);
+        this.fileOffset = stat.size;
+        const text = this.lineBuffer + buf.toString("utf-8");
+        const lines = text.split("\n");
+        this.lineBuffer = lines.pop() || "";
+        for (const line of lines) {
+          if (!line.trim()) continue;
+          try {
+            const event = JSON.parse(line);
+            if (this.callback) {
+              this.callback(event);
+            }
+          } catch (e) {
+            console.log(`[EventsWatcher] Failed to parse line: ${e}`);
+          }
+        }
+      } finally {
+        await handle.close();
+      }
+    } catch (e) {
+    } finally {
+      this.reading = false;
+    }
+  }
+  stop() {
+    this.stopped = true;
+    if (this.fileExistsTimer) {
+      clearInterval(this.fileExistsTimer);
+      this.fileExistsTimer = null;
+    }
+    if (this.watcher) {
+      this.watcher.close();
+      this.watcher = null;
+    }
+    if (this.pollTimer) {
+      clearInterval(this.pollTimer);
+      this.pollTimer = null;
+    }
+    this.callback = null;
+  }
+};
+function formatToolStatus(toolName, args) {
+  const base = (p) => typeof p === "string" ? path.basename(p) : "";
+  switch (toolName) {
+    case "view":
+      return `Reading ${base(args.path)}`;
+    case "edit":
+      return `Editing ${base(args.path)}`;
+    case "create":
+      return `Creating ${base(args.path)}`;
+    case "powershell":
+      const cmd = args.command || "";
+      return `Running: ${cmd.length > 40 ? cmd.slice(0, 40) + "\u2026" : cmd}`;
+    case "glob":
+      return `Finding files: ${args.pattern || ""}`;
+    case "grep":
+      return `Searching: ${args.pattern || ""}`;
+    case "web_fetch":
+      return `Fetching: ${args.url || ""}`;
+    case "task":
+      return `Subtask: ${args.description || "running"}`;
+    case "ask_user":
+      return "Waiting for your answer";
+    case "report_intent":
+      return `${args.intent || "Working"}`;
+    case "sql":
+      return `Query: ${args.description || "running"}`;
+    default:
+      return `Using ${toolName}`;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EventsWatcher,
+  formatToolStatus
+});