move pi-mono into companion-cloud as apps/companion-os

- Copy all pi-mono source into apps/companion-os/
- Update Dockerfile to COPY pre-built binary instead of downloading from GitHub Releases
- Update deploy-staging.yml to build pi from source (bun compile) before Docker build
- Add apps/companion-os/** to path triggers
- No more cross-repo dispatch needed

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

packages/coding-agent/test/rpc.test.ts

@@ -0,0 +1,357 @@
+import { existsSync, readdirSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import type { AgentEvent } from "@mariozechner/pi-agent-core";
+import { afterEach, beforeEach, describe, expect, test } from "vitest";
+import { RpcClient } from "../src/modes/rpc/rpc-client.js";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+/**
+ * RPC mode tests.
+ */
+describe.skipIf(
+  !process.env.ANTHROPIC_API_KEY && !process.env.ANTHROPIC_OAUTH_TOKEN,
+)("RPC mode", () => {
+  let client: RpcClient;
+  let sessionDir: string;
+
+  beforeEach(() => {
+    sessionDir = join(tmpdir(), `pi-rpc-test-${Date.now()}`);
+    client = new RpcClient({
+      cliPath: join(__dirname, "..", "dist", "cli.js"),
+      cwd: join(__dirname, ".."),
+      env: { PI_CODING_AGENT_DIR: sessionDir },
+      provider: "anthropic",
+      model: "claude-sonnet-4-5",
+    });
+  });
+
+  afterEach(async () => {
+    await client.stop();
+    if (sessionDir && existsSync(sessionDir)) {
+      rmSync(sessionDir, { recursive: true });
+    }
+  });
+
+  test("should get state", async () => {
+    await client.start();
+    const state = await client.getState();
+
+    expect(state.model).toBeDefined();
+    expect(state.model?.provider).toBe("anthropic");
+    expect(state.model?.id).toBe("claude-sonnet-4-5");
+    expect(state.isStreaming).toBe(false);
+    expect(state.messageCount).toBe(0);
+  }, 30000);
+
+  test("should save messages to session file", async () => {
+    await client.start();
+
+    // Send prompt and wait for completion
+    const events = await client.promptAndWait(
+      "Reply with just the word 'hello'",
+    );
+
+    // Should have message events
+    const messageEndEvents = events.filter((e) => e.type === "message_end");
+    expect(messageEndEvents.length).toBeGreaterThanOrEqual(2); // user + assistant
+
+    // Wait for file writes
+    await new Promise((resolve) => setTimeout(resolve, 200));
+
+    // Verify session file
+    const sessionsPath = join(sessionDir, "sessions");
+    expect(existsSync(sessionsPath)).toBe(true);
+
+    const sessionDirs = readdirSync(sessionsPath);
+    expect(sessionDirs.length).toBeGreaterThan(0);
+
+    const cwdSessionDir = join(sessionsPath, sessionDirs[0]);
+    const sessionFiles = readdirSync(cwdSessionDir).filter((f) =>
+      f.endsWith(".jsonl"),
+    );
+    expect(sessionFiles.length).toBe(1);
+
+    const sessionContent = readFileSync(
+      join(cwdSessionDir, sessionFiles[0]),
+      "utf8",
+    );
+    const entries = sessionContent
+      .trim()
+      .split("\n")
+      .map((line) => JSON.parse(line));
+
+    // First entry should be session header
+    expect(entries[0].type).toBe("session");
+
+    // Should have user and assistant messages
+    const messages = entries.filter(
+      (e: { type: string }) => e.type === "message",
+    );
+    expect(messages.length).toBeGreaterThanOrEqual(2);
+
+    const roles = messages.map(
+      (m: { message: { role: string } }) => m.message.role,
+    );
+    expect(roles).toContain("user");
+    expect(roles).toContain("assistant");
+  }, 90000);
+
+  test("should handle manual compaction", async () => {
+    await client.start();
+
+    // First send a prompt to have messages to compact
+    await client.promptAndWait("Say hello");
+
+    // Compact
+    const result = await client.compact();
+    expect(result.summary).toBeDefined();
+    expect(result.tokensBefore).toBeGreaterThan(0);
+
+    // Wait for file writes
+    await new Promise((resolve) => setTimeout(resolve, 200));
+
+    // Verify compaction in session file
+    const sessionsPath = join(sessionDir, "sessions");
+    const sessionDirs = readdirSync(sessionsPath);
+    const cwdSessionDir = join(sessionsPath, sessionDirs[0]);
+    const sessionFiles = readdirSync(cwdSessionDir).filter((f) =>
+      f.endsWith(".jsonl"),
+    );
+    const sessionContent = readFileSync(
+      join(cwdSessionDir, sessionFiles[0]),
+      "utf8",
+    );
+    const entries = sessionContent
+      .trim()
+      .split("\n")
+      .map((line) => JSON.parse(line));
+
+    const compactionEntries = entries.filter(
+      (e: { type: string }) => e.type === "compaction",
+    );
+    expect(compactionEntries.length).toBe(1);
+    expect(compactionEntries[0].summary).toBeDefined();
+  }, 120000);
+
+  test("should execute bash command", async () => {
+    await client.start();
+
+    const result = await client.bash("echo hello");
+    expect(result.output.trim()).toBe("hello");
+    expect(result.exitCode).toBe(0);
+    expect(result.cancelled).toBe(false);
+  }, 30000);
+
+  test("should add bash output to context", async () => {
+    await client.start();
+
+    // First send a prompt to initialize session
+    await client.promptAndWait("Say hi");
+
+    // Run bash command
+    const uniqueValue = `test-${Date.now()}`;
+    await client.bash(`echo ${uniqueValue}`);
+
+    // Wait for file writes
+    await new Promise((resolve) => setTimeout(resolve, 200));
+
+    // Verify bash message in session
+    const sessionsPath = join(sessionDir, "sessions");
+    const sessionDirs = readdirSync(sessionsPath);
+    const cwdSessionDir = join(sessionsPath, sessionDirs[0]);
+    const sessionFiles = readdirSync(cwdSessionDir).filter((f) =>
+      f.endsWith(".jsonl"),
+    );
+    const sessionContent = readFileSync(
+      join(cwdSessionDir, sessionFiles[0]),
+      "utf8",
+    );
+    const entries = sessionContent
+      .trim()
+      .split("\n")
+      .map((line) => JSON.parse(line));
+
+    const bashMessages = entries.filter(
+      (e: { type: string; message?: { role: string } }) =>
+        e.type === "message" && e.message?.role === "bashExecution",
+    );
+    expect(bashMessages.length).toBe(1);
+    expect(bashMessages[0].message.output).toContain(uniqueValue);
+  }, 90000);
+
+  test("should include bash output in LLM context", async () => {
+    await client.start();
+
+    // Run a bash command with a unique value
+    const uniqueValue = `unique-${Date.now()}`;
+    await client.bash(`echo ${uniqueValue}`);
+
+    // Ask the LLM what the output was
+    const events = await client.promptAndWait(
+      "What was the exact output of the echo command I just ran? Reply with just the value, nothing else.",
+    );
+
+    // Find assistant's response
+    const messageEndEvents = events.filter(
+      (e) => e.type === "message_end",
+    ) as AgentEvent[];
+    const assistantMessage = messageEndEvents.find(
+      (e) => e.type === "message_end" && e.message?.role === "assistant",
+    ) as any;
+
+    expect(assistantMessage).toBeDefined();
+
+    const textContent = assistantMessage.message.content.find(
+      (c: any) => c.type === "text",
+    );
+    expect(textContent?.text).toContain(uniqueValue);
+  }, 90000);
+
+  test("should set and get thinking level", async () => {
+    await client.start();
+
+    // Set thinking level
+    await client.setThinkingLevel("high");
+
+    // Verify via state
+    const state = await client.getState();
+    expect(state.thinkingLevel).toBe("high");
+  }, 30000);
+
+  test("should cycle thinking level", async () => {
+    await client.start();
+
+    // Get initial level
+    const initialState = await client.getState();
+    const initialLevel = initialState.thinkingLevel;
+
+    // Cycle
+    const result = await client.cycleThinkingLevel();
+    expect(result).toBeDefined();
+    expect(result!.level).not.toBe(initialLevel);
+
+    // Verify via state
+    const newState = await client.getState();
+    expect(newState.thinkingLevel).toBe(result!.level);
+  }, 30000);
+
+  test("should get available models", async () => {
+    await client.start();
+
+    const models = await client.getAvailableModels();
+    expect(models.length).toBeGreaterThan(0);
+
+    // All models should have required fields
+    for (const model of models) {
+      expect(model.provider).toBeDefined();
+      expect(model.id).toBeDefined();
+      expect(model.contextWindow).toBeGreaterThan(0);
+      expect(typeof model.reasoning).toBe("boolean");
+    }
+  }, 30000);
+
+  test("should get session stats", async () => {
+    await client.start();
+
+    // Send a prompt first
+    await client.promptAndWait("Hello");
+
+    const stats = await client.getSessionStats();
+    expect(stats.sessionFile).toBeDefined();
+    expect(stats.sessionId).toBeDefined();
+    expect(stats.userMessages).toBeGreaterThanOrEqual(1);
+    expect(stats.assistantMessages).toBeGreaterThanOrEqual(1);
+  }, 90000);
+
+  test("should create new session", async () => {
+    await client.start();
+
+    // Send a prompt
+    await client.promptAndWait("Hello");
+
+    // Verify messages exist
+    let state = await client.getState();
+    expect(state.messageCount).toBeGreaterThan(0);
+
+    // New session
+    await client.newSession();
+
+    // Verify messages cleared
+    state = await client.getState();
+    expect(state.messageCount).toBe(0);
+  }, 90000);
+
+  test("should export to HTML", async () => {
+    await client.start();
+
+    // Send a prompt first
+    await client.promptAndWait("Hello");
+
+    // Export
+    const result = await client.exportHtml();
+    expect(result.path).toBeDefined();
+    expect(result.path.endsWith(".html")).toBe(true);
+    expect(existsSync(result.path)).toBe(true);
+  }, 90000);
+
+  test("should get last assistant text", async () => {
+    await client.start();
+
+    // Initially null
+    let text = await client.getLastAssistantText();
+    expect(text).toBeUndefined();
+
+    // Send prompt
+    await client.promptAndWait("Reply with just: test123");
+
+    // Should have text now
+    text = await client.getLastAssistantText();
+    expect(text).toContain("test123");
+  }, 90000);
+
+  test("should set and get session name", async () => {
+    await client.start();
+
+    // Initially undefined
+    let state = await client.getState();
+    expect(state.sessionName).toBeUndefined();
+
+    // Send a prompt first - session files are only written after first assistant message
+    await client.promptAndWait("Reply with just 'ok'");
+
+    // Set name
+    await client.setSessionName("my-test-session");
+
+    // Verify via state
+    state = await client.getState();
+    expect(state.sessionName).toBe("my-test-session");
+
+    // Wait for file writes
+    await new Promise((resolve) => setTimeout(resolve, 200));
+
+    // Verify session_info entry in session file
+    const sessionsPath = join(sessionDir, "sessions");
+    const sessionDirs = readdirSync(sessionsPath);
+    const cwdSessionDir = join(sessionsPath, sessionDirs[0]);
+    const sessionFiles = readdirSync(cwdSessionDir).filter((f) =>
+      f.endsWith(".jsonl"),
+    );
+    const sessionContent = readFileSync(
+      join(cwdSessionDir, sessionFiles[0]),
+      "utf8",
+    );
+    const entries = sessionContent
+      .trim()
+      .split("\n")
+      .map((line) => JSON.parse(line));
+
+    const sessionInfoEntries = entries.filter(
+      (e: { type: string }) => e.type === "session_info",
+    );
+    expect(sessionInfoEntries.length).toBe(1);
+    expect(sessionInfoEntries[0].name).toBe("my-test-session");
+  }, 60000);
+});