@wangyaoshen/remux 0.3.8-dev.a8ceb0c

package/tests/workspace-head.test.js

@@ -0,0 +1,116 @@
+/**
+ * Tests for workspace_head — multi-device shared state.
+ */
+import { describe, it, expect, beforeAll, afterAll } from "vitest";
+import Database from "better-sqlite3";
+import { _resetDbForTest, closeDb } from "../src/store.js";
+import { initWorkspaceHeadTable, getHead, updateHead } from "../src/workspace-head.js";
+
+describe("workspace_head", () => {
+  let db;
+
+  beforeAll(() => {
+    db = new Database(":memory:");
+    db.pragma("journal_mode = WAL");
+    db.pragma("foreign_keys = ON");
+    _resetDbForTest(db);
+
+    // Create minimal schema needed
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS workspace_head (
+        id TEXT PRIMARY KEY DEFAULT 'global',
+        session_name TEXT NOT NULL,
+        tab_id INTEGER NOT NULL,
+        topic_id TEXT,
+        view TEXT NOT NULL DEFAULT 'live',
+        revision INTEGER NOT NULL DEFAULT 0,
+        updated_by_device TEXT,
+        updated_at INTEGER NOT NULL
+      );
+    `);
+  });
+
+  afterAll(() => {
+    closeDb();
+  });
+
+  it("returns null when no head exists", () => {
+    const head = getHead();
+    expect(head).toBeNull();
+  });
+
+  it("creates head on first updateHead call", () => {
+    const head = updateHead({
+      sessionName: "main",
+      tabId: 0,
+      view: "live",
+    }, "device-1");
+
+    expect(head).toBeDefined();
+    expect(head.sessionName).toBe("main");
+    expect(head.tabId).toBe(0);
+    expect(head.view).toBe("live");
+    expect(head.revision).toBe(1);
+    expect(head.updatedByDevice).toBe("device-1");
+    expect(head.updatedAt).toBeGreaterThan(0);
+  });
+
+  it("getHead returns the created head", () => {
+    const head = getHead();
+    expect(head).not.toBeNull();
+    expect(head.sessionName).toBe("main");
+    expect(head.tabId).toBe(0);
+    expect(head.revision).toBe(1);
+  });
+
+  it("increments revision on update", () => {
+    const head1 = updateHead({ tabId: 1 }, "device-2");
+    expect(head1.revision).toBe(2);
+    expect(head1.tabId).toBe(1);
+    expect(head1.updatedByDevice).toBe("device-2");
+    // sessionName should be preserved from previous
+    expect(head1.sessionName).toBe("main");
+
+    const head2 = updateHead({ tabId: 2 }, "device-1");
+    expect(head2.revision).toBe(3);
+    expect(head2.tabId).toBe(2);
+  });
+
+  it("updates session and resets tab", () => {
+    const head = updateHead({
+      sessionName: "logs",
+      tabId: 5,
+      view: "workspace",
+    }, "device-3");
+
+    expect(head.sessionName).toBe("logs");
+    expect(head.tabId).toBe(5);
+    expect(head.view).toBe("workspace");
+    expect(head.revision).toBe(4);
+  });
+
+  it("handles topicId updates", () => {
+    const head1 = updateHead({ topicId: "topic-abc" }, "device-1");
+    expect(head1.topicId).toBe("topic-abc");
+
+    const head2 = updateHead({ topicId: null }, "device-1");
+    expect(head2.topicId).toBeNull();
+  });
+
+  it("preserves fields not specified in partial update", () => {
+    // Set everything
+    updateHead({
+      sessionName: "work",
+      tabId: 10,
+      topicId: "topic-xyz",
+      view: "inspect",
+    }, "device-1");
+
+    // Update only view
+    const head = updateHead({ view: "live" }, "device-2");
+    expect(head.sessionName).toBe("work");
+    expect(head.tabId).toBe(10);
+    expect(head.topicId).toBe("topic-xyz");
+    expect(head.view).toBe("live");
+  });
+});

package/tests/workspace.test.js

@@ -0,0 +1,417 @@
+/**
+ * Tests for AI workspace primitives: topics, runs, artifacts, approvals.
+ * Covers CRUD operations in store.ts and high-level workspace.ts functions.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import Database from "better-sqlite3";
+import {
+  _resetDbForTest,
+  closeDb,
+  createTopic,
+  updateTopic,
+  listTopics,
+  deleteTopic,
+  createRun,
+  updateRun,
+  listRuns,
+  createArtifact,
+  listArtifacts,
+  createApproval,
+  listApprovals,
+  resolveApproval,
+} from "../src/store.ts";
+
+/** Create an in-memory SQLite DB with the full schema including workspace tables. */
+function createTestDb() {
+  const db = new Database(":memory:");
+  db.pragma("journal_mode = WAL");
+  db.pragma("foreign_keys = ON");
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS sessions (
+      name TEXT PRIMARY KEY,
+      created_at INTEGER NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS tabs (
+      id INTEGER PRIMARY KEY,
+      session_name TEXT NOT NULL,
+      title TEXT NOT NULL DEFAULT 'Tab',
+      scrollback BLOB,
+      ended INTEGER NOT NULL DEFAULT 0,
+      FOREIGN KEY (session_name) REFERENCES sessions(name) ON DELETE CASCADE
+    );
+    CREATE TABLE IF NOT EXISTS devices (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL,
+      fingerprint TEXT NOT NULL,
+      trust TEXT NOT NULL DEFAULT 'untrusted',
+      created_at INTEGER NOT NULL,
+      last_seen INTEGER NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS pair_codes (
+      code TEXT PRIMARY KEY,
+      created_by TEXT NOT NULL,
+      expires_at INTEGER NOT NULL,
+      FOREIGN KEY (created_by) REFERENCES devices(id) ON DELETE CASCADE
+    );
+    CREATE TABLE IF NOT EXISTS settings (
+      key TEXT PRIMARY KEY,
+      value TEXT
+    );
+    CREATE TABLE IF NOT EXISTS push_subscriptions (
+      device_id TEXT PRIMARY KEY,
+      endpoint TEXT NOT NULL,
+      p256dh TEXT NOT NULL,
+      auth TEXT NOT NULL,
+      created_at INTEGER NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS topics (
+      id TEXT PRIMARY KEY,
+      session_name TEXT NOT NULL,
+      title TEXT NOT NULL,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS runs (
+      id TEXT PRIMARY KEY,
+      topic_id TEXT REFERENCES topics(id),
+      session_name TEXT NOT NULL,
+      tab_id INTEGER,
+      command TEXT,
+      exit_code INTEGER,
+      started_at INTEGER NOT NULL,
+      ended_at INTEGER,
+      status TEXT DEFAULT 'running'
+    );
+    CREATE TABLE IF NOT EXISTS artifacts (
+      id TEXT PRIMARY KEY,
+      run_id TEXT REFERENCES runs(id),
+      topic_id TEXT REFERENCES topics(id),
+      session_name TEXT,
+      type TEXT NOT NULL,
+      title TEXT,
+      content TEXT,
+      created_at INTEGER NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS approvals (
+      id TEXT PRIMARY KEY,
+      run_id TEXT REFERENCES runs(id),
+      topic_id TEXT REFERENCES topics(id),
+      title TEXT NOT NULL,
+      description TEXT,
+      status TEXT DEFAULT 'pending',
+      created_at INTEGER NOT NULL,
+      resolved_at INTEGER
+    );
+    CREATE VIRTUAL TABLE IF NOT EXISTS fts_index USING fts5(
+      entity_type, entity_id, title, content,
+      tokenize='porter unicode61'
+    );
+    CREATE TABLE IF NOT EXISTS memory_notes (
+      id TEXT PRIMARY KEY,
+      content TEXT NOT NULL,
+      pinned INTEGER DEFAULT 0,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS commands (
+      id TEXT PRIMARY KEY,
+      session_name TEXT NOT NULL,
+      tab_id INTEGER NOT NULL,
+      command TEXT,
+      exit_code INTEGER,
+      cwd TEXT,
+      started_at INTEGER NOT NULL,
+      ended_at INTEGER
+    );
+  `);
+  return db;
+}
+
+// ── Topics ──────────────────────────────────────────────────────
+
+describe("workspace: topics CRUD", () => {
+  let db;
+
+  beforeEach(() => {
+    db = createTestDb();
+    _resetDbForTest(db);
+  });
+
+  afterEach(() => {
+    closeDb();
+  });
+
+  it("creates a topic with generated ID and timestamps", () => {
+    const topic = createTopic("main", "My first topic");
+    expect(topic.id).toBeTruthy();
+    expect(topic.id.length).toBeGreaterThan(0);
+    expect(topic.sessionName).toBe("main");
+    expect(topic.title).toBe("My first topic");
+    expect(topic.createdAt).toBeGreaterThan(0);
+    expect(topic.updatedAt).toBe(topic.createdAt);
+  });
+
+  it("lists topics filtered by sessionName", () => {
+    createTopic("main", "Topic A");
+    createTopic("main", "Topic B");
+    createTopic("work", "Topic C");
+
+    const mainTopics = listTopics("main");
+    expect(mainTopics).toHaveLength(2);
+    expect(mainTopics[0].title).toBe("Topic A");
+    expect(mainTopics[1].title).toBe("Topic B");
+
+    const workTopics = listTopics("work");
+    expect(workTopics).toHaveLength(1);
+    expect(workTopics[0].title).toBe("Topic C");
+  });
+
+  it("lists all topics when no sessionName filter", () => {
+    createTopic("main", "Topic A");
+    createTopic("work", "Topic B");
+
+    const all = listTopics();
+    expect(all).toHaveLength(2);
+  });
+
+  it("updates a topic title and updatedAt", () => {
+    const topic = createTopic("main", "Old title");
+    const updated = updateTopic(topic.id, "New title");
+    expect(updated).toBe(true);
+
+    const topics = listTopics("main");
+    expect(topics[0].title).toBe("New title");
+    expect(topics[0].updatedAt).toBeGreaterThanOrEqual(topics[0].createdAt);
+  });
+
+  it("updateTopic returns false for nonexistent ID", () => {
+    const result = updateTopic("nonexistent", "Title");
+    expect(result).toBe(false);
+  });
+
+  it("deletes a topic", () => {
+    const topic = createTopic("main", "To delete");
+    expect(deleteTopic(topic.id)).toBe(true);
+    expect(listTopics("main")).toHaveLength(0);
+  });
+
+  it("deleteTopic returns false for nonexistent ID", () => {
+    expect(deleteTopic("nonexistent")).toBe(false);
+  });
+});
+
+// ── Runs ────────────────────────────────────────────────────────
+
+describe("workspace: runs CRUD", () => {
+  let db;
+
+  beforeEach(() => {
+    db = createTestDb();
+    _resetDbForTest(db);
+  });
+
+  afterEach(() => {
+    closeDb();
+  });
+
+  it("creates a run with default status 'running'", () => {
+    const topic = createTopic("main", "Test topic");
+    const run = createRun({
+      topicId: topic.id,
+      sessionName: "main",
+      tabId: 0,
+      command: "ls -la",
+    });
+    expect(run.id).toBeTruthy();
+    expect(run.topicId).toBe(topic.id);
+    expect(run.sessionName).toBe("main");
+    expect(run.command).toBe("ls -la");
+    expect(run.status).toBe("running");
+    expect(run.startedAt).toBeGreaterThan(0);
+    expect(run.endedAt).toBeNull();
+    expect(run.exitCode).toBeNull();
+  });
+
+  it("creates a run without topicId", () => {
+    const run = createRun({
+      sessionName: "main",
+      command: "echo hello",
+    });
+    expect(run.id).toBeTruthy();
+    expect(run.topicId).toBeNull();
+    expect(run.status).toBe("running");
+  });
+
+  it("updates run exit code and status", () => {
+    const run = createRun({ sessionName: "main", command: "test" });
+    const updated = updateRun(run.id, { exitCode: 0, status: "completed" });
+    expect(updated).toBe(true);
+
+    const runs = listRuns();
+    expect(runs[0].exitCode).toBe(0);
+    expect(runs[0].status).toBe("completed");
+    expect(runs[0].endedAt).toBeGreaterThan(0);
+  });
+
+  it("lists runs filtered by topicId", () => {
+    const topic = createTopic("main", "T");
+    createRun({ topicId: topic.id, sessionName: "main", command: "a" });
+    createRun({ topicId: topic.id, sessionName: "main", command: "b" });
+    createRun({ sessionName: "main", command: "c" });
+
+    const topicRuns = listRuns(topic.id);
+    expect(topicRuns).toHaveLength(2);
+
+    const allRuns = listRuns();
+    expect(allRuns).toHaveLength(3);
+  });
+
+  it("updateRun returns false for nonexistent ID", () => {
+    expect(updateRun("nonexistent", { status: "failed" })).toBe(false);
+  });
+});
+
+// ── Artifacts ───────────────────────────────────────────────────
+
+describe("workspace: artifacts CRUD", () => {
+  let db;
+
+  beforeEach(() => {
+    db = createTestDb();
+    _resetDbForTest(db);
+  });
+
+  afterEach(() => {
+    closeDb();
+  });
+
+  it("creates an artifact with type and content", () => {
+    const topic = createTopic("main", "T");
+    const artifact = createArtifact({
+      topicId: topic.id,
+      type: "snapshot",
+      title: "Terminal snapshot",
+      content: "$ ls\nfoo bar",
+    });
+    expect(artifact.id).toBeTruthy();
+    expect(artifact.topicId).toBe(topic.id);
+    expect(artifact.type).toBe("snapshot");
+    expect(artifact.content).toBe("$ ls\nfoo bar");
+    expect(artifact.createdAt).toBeGreaterThan(0);
+  });
+
+  it("creates an artifact linked to a run", () => {
+    const run = createRun({ sessionName: "main", command: "ls" });
+    const artifact = createArtifact({
+      runId: run.id,
+      type: "command-card",
+      title: "ls output",
+      content: "foo bar",
+    });
+    expect(artifact.runId).toBe(run.id);
+  });
+
+  it("lists artifacts filtered by topicId", () => {
+    const topic = createTopic("main", "T");
+    createArtifact({ topicId: topic.id, type: "note", title: "N1", content: "x" });
+    createArtifact({ topicId: topic.id, type: "note", title: "N2", content: "y" });
+    createArtifact({ type: "snapshot", title: "S", content: "z" });
+
+    const topicArtifacts = listArtifacts({ topicId: topic.id });
+    expect(topicArtifacts).toHaveLength(2);
+
+    const allArtifacts = listArtifacts({});
+    expect(allArtifacts).toHaveLength(3);
+  });
+
+  it("lists artifacts filtered by runId", () => {
+    const run = createRun({ sessionName: "main", command: "test" });
+    createArtifact({ runId: run.id, type: "command-card", title: "C", content: "x" });
+
+    const runArtifacts = listArtifacts({ runId: run.id });
+    expect(runArtifacts).toHaveLength(1);
+  });
+});
+
+// ── Approvals ───────────────────────────────────────────────────
+
+describe("workspace: approvals CRUD", () => {
+  let db;
+
+  beforeEach(() => {
+    db = createTestDb();
+    _resetDbForTest(db);
+  });
+
+  afterEach(() => {
+    closeDb();
+  });
+
+  it("creates an approval with pending status", () => {
+    const approval = createApproval({
+      title: "Deploy to production?",
+      description: "Running deploy script",
+    });
+    expect(approval.id).toBeTruthy();
+    expect(approval.title).toBe("Deploy to production?");
+    expect(approval.status).toBe("pending");
+    expect(approval.createdAt).toBeGreaterThan(0);
+    expect(approval.resolvedAt).toBeNull();
+  });
+
+  it("creates an approval linked to topic and run", () => {
+    const topic = createTopic("main", "T");
+    const run = createRun({ topicId: topic.id, sessionName: "main", command: "deploy" });
+    const approval = createApproval({
+      runId: run.id,
+      topicId: topic.id,
+      title: "Approve deploy",
+    });
+    expect(approval.runId).toBe(run.id);
+    expect(approval.topicId).toBe(topic.id);
+  });
+
+  it("lists approvals filtered by status", () => {
+    createApproval({ title: "A1" });
+    createApproval({ title: "A2" });
+
+    const pending = listApprovals("pending");
+    expect(pending).toHaveLength(2);
+
+    const approved = listApprovals("approved");
+    expect(approved).toHaveLength(0);
+  });
+
+  it("lists all approvals when no status filter", () => {
+    createApproval({ title: "A1" });
+    createApproval({ title: "A2" });
+
+    const all = listApprovals();
+    expect(all).toHaveLength(2);
+  });
+
+  it("resolves an approval as approved", () => {
+    const approval = createApproval({ title: "Test" });
+    const result = resolveApproval(approval.id, "approved");
+    expect(result).toBe(true);
+
+    const list = listApprovals("approved");
+    expect(list).toHaveLength(1);
+    expect(list[0].status).toBe("approved");
+    expect(list[0].resolvedAt).toBeGreaterThan(0);
+  });
+
+  it("resolves an approval as rejected", () => {
+    const approval = createApproval({ title: "Test" });
+    resolveApproval(approval.id, "rejected");
+
+    const list = listApprovals("rejected");
+    expect(list).toHaveLength(1);
+    expect(list[0].status).toBe("rejected");
+  });
+
+  it("resolveApproval returns false for nonexistent ID", () => {
+    expect(resolveApproval("nonexistent", "approved")).toBe(false);
+  });
+});

package/tsconfig.backend.json

@@ -0,0 +1,11 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "rootDir": "src",
+    "outDir": "dist",
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true
+  },
+  "include": ["src/backend/**/*.ts"]
+}

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "declaration": false,
+    "types": ["node"]
+  },
+  "include": ["src/**/*.ts"]
+}

package/tui/client/client_test.go

@@ -0,0 +1,125 @@
+package client
+
+import (
+	"net/url"
+	"testing"
+)
+
+func TestConnectionBuildWSURL(t *testing.T) {
+	tests := []struct {
+		name     string
+		host     Host
+		path     string
+		wantScheme string
+	}{
+		{
+			name:       "http becomes ws",
+			host:       Host{URL: "http://localhost:8767", Token: "abc"},
+			path:       "/ws/control",
+			wantScheme: "ws",
+		},
+		{
+			name:       "https becomes wss",
+			host:       Host{URL: "https://my.devtunnels.ms", Token: "xyz"},
+			path:       "/ws/terminal",
+			wantScheme: "wss",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			conn := NewConnection(tt.host, "")
+			wsURL, err := conn.buildWSURL(tt.path)
+			if err != nil {
+				t.Fatalf("buildWSURL failed: %v", err)
+			}
+
+			parsed, err := url.Parse(wsURL)
+			if err != nil {
+				t.Fatalf("parse URL failed: %v", err)
+			}
+
+			if parsed.Scheme != tt.wantScheme {
+				t.Errorf("scheme = %q, want %q", parsed.Scheme, tt.wantScheme)
+			}
+			if parsed.Path != tt.path {
+				t.Errorf("path = %q, want %q", parsed.Path, tt.path)
+			}
+			if parsed.Query().Get("token") != tt.host.Token {
+				t.Errorf("token = %q, want %q", parsed.Query().Get("token"), tt.host.Token)
+			}
+		})
+	}
+}
+
+func TestHostManagerSessions(t *testing.T) {
+	manager := NewHostManager()
+
+	// Simulate state updates from two hosts.
+	manager.mu.Lock()
+	manager.updateSessionsFromState("host-a", &StateSnapshot{
+		Sessions: []SessionState{
+			{Name: "session-1", Attached: true, Windows: 1},
+			{Name: "session-2", Attached: false, Windows: 2},
+		},
+	})
+	manager.updateSessionsFromState("host-b", &StateSnapshot{
+		Sessions: []SessionState{
+			{Name: "session-3", Attached: false, Windows: 1},
+		},
+	})
+	manager.mu.Unlock()
+
+	sessions := manager.Sessions()
+	if len(sessions) != 3 {
+		t.Fatalf("expected 3 sessions, got %d", len(sessions))
+	}
+
+	// Verify sessions are from the right hosts.
+	hostCounts := map[string]int{}
+	for _, s := range sessions {
+		hostCounts[s.HostName]++
+	}
+	if hostCounts["host-a"] != 2 {
+		t.Errorf("expected 2 sessions from host-a, got %d", hostCounts["host-a"])
+	}
+	if hostCounts["host-b"] != 1 {
+		t.Errorf("expected 1 session from host-b, got %d", hostCounts["host-b"])
+	}
+}
+
+func TestHostManagerStateUpdateReplacesOldSessions(t *testing.T) {
+	manager := NewHostManager()
+
+	// First update.
+	manager.mu.Lock()
+	manager.updateSessionsFromState("host-a", &StateSnapshot{
+		Sessions: []SessionState{
+			{Name: "old-session", Attached: false, Windows: 1},
+		},
+	})
+	manager.mu.Unlock()
+
+	if len(manager.Sessions()) != 1 {
+		t.Fatalf("expected 1 session after first update")
+	}
+
+	// Second update replaces the first.
+	manager.mu.Lock()
+	manager.updateSessionsFromState("host-a", &StateSnapshot{
+		Sessions: []SessionState{
+			{Name: "new-session-1", Attached: true, Windows: 1},
+			{Name: "new-session-2", Attached: false, Windows: 1},
+		},
+	})
+	manager.mu.Unlock()
+
+	sessions := manager.Sessions()
+	if len(sessions) != 2 {
+		t.Fatalf("expected 2 sessions after replacement, got %d", len(sessions))
+	}
+	if sessions[0].Name != "new-session-1" {
+		t.Errorf("expected first session 'new-session-1', got %q", sessions[0].Name)
+	}
+}
+