@ericsanchezok/meta-synergy 1.1.26 → 1.2.18

package/test/control-socket.test.ts

@@ -27,13 +27,49 @@ afterAll(async () => {
 describe("meta-synergy control socket", () => {
   test("exposes runtime control actions over the local socket", async () => {
     const runtime = await MetaSynergyRuntime.create()
+    const envID = runtime.host.envID
+    if (!envID) throw new Error("Expected runtime envID")
     await runtime.control.start()
     try {
       expect(await MetaSynergyControlClient.isAvailable()).toBe(true)
 
+      const mode = await MetaSynergyControlClient.request<{
+        mode: string
+        ownership: { local: { owned: boolean; activeOwnerID: string | null } }
+      }>({ action: "runtime.mode" })
+      expect(mode.mode).toBe("standalone")
+      expect(mode.ownership.local.owned).toBe(false)
+
       const approval = await MetaSynergyControlClient.request<{ mode: string }>({ action: "approval.get" })
       expect(approval.mode).toBe("manual")
 
+      const managed = await MetaSynergyControlClient.request<{
+        mode: string
+        ownership: { local: { owned: boolean; activeOwnerID: string | null } }
+        connectionStatus: string
+      }>({ action: "runtime.enter_managed" })
+      expect(managed.mode).toBe("managed")
+      expect(managed.ownership.local.owned).toBe(true)
+      expect(managed.ownership.local.activeOwnerID).toMatch(/^env_/)
+
+      expect(managed.connectionStatus).toBe("disconnected")
+
+      const standalone = await MetaSynergyControlClient.request<{
+        mode: string
+        ownership: { local: { owned: boolean; activeOwnerID: string | null } }
+        connectionStatus: string
+      }>({ action: "runtime.set_mode", mode: "standalone" })
+      expect(standalone.mode).toBe("standalone")
+      expect(standalone.ownership.local.owned).toBe(false)
+
+      const managedAgain = await MetaSynergyControlClient.request<{
+        mode: string
+        ownership: { local: { owned: boolean; activeOwnerID: string | null } }
+        connectionStatus: string
+      }>({ action: "runtime.enter_managed" })
+      expect(managedAgain.mode).toBe("managed")
+      expect(managedAgain.ownership.local.owned).toBe(true)
+
       await MetaSynergyControlClient.request({ action: "approval.set", mode: "trusted-only" })
       const collaboration = await MetaSynergyControlClient.request<{ enabled: boolean; approvalMode: string }>({
         action: "collaboration.status",
@@ -53,6 +89,93 @@ describe("meta-synergy control socket", () => {
         value: "agent_test",
       })
       expect(trust.agents).toContain("agent_test")
+
+      const caller = {
+        type: "holos",
+        agentID: "agent_test",
+        ownerUserID: 42,
+        profile: { source: "control-socket-test" },
+      }
+
+      const opened = await MetaSynergyControlClient.request<{
+        version: 1
+        requestID: string
+        ok: true
+        tool: "session"
+        action: "open"
+        result: {
+          title: string
+          metadata: {
+            action: "open"
+            status: string
+            sessionID?: string
+            remoteAgentID?: string
+            remoteOwnerUserID?: number
+            label?: string
+            backend: "remote"
+          }
+          output: string
+        }
+      }>({
+        action: "meta.execute",
+        caller,
+        body: {
+          version: 1,
+          requestID: "req_open",
+          envID,
+          tool: "session",
+          action: "open",
+          payload: {
+            action: "open",
+            label: "local proxy test",
+          },
+        },
+      })
+      expect(opened.ok).toBe(true)
+      expect(opened.tool).toBe("session")
+      expect(opened.action).toBe("open")
+      expect(opened.result.metadata.status).toBe("opened")
+      expect(opened.result.metadata.remoteAgentID).toBe("agent_test")
+      expect(opened.result.metadata.remoteOwnerUserID).toBe(42)
+      expect(opened.result.metadata.label).toBe("local proxy test")
+      expect(opened.result.metadata.sessionID).toBeTruthy()
+
+      const listed = await MetaSynergyControlClient.request<{
+        version: 1
+        requestID: string
+        ok: true
+        tool: "process"
+        action: "list"
+        result: {
+          title: string
+          metadata: {
+            action: "list"
+            processes?: Array<{ processId: string }>
+            hostSessionID: string
+            envID: string
+            backend: "remote"
+          }
+          output: string
+        }
+      }>({
+        action: "meta.execute",
+        caller,
+        body: {
+          version: 1,
+          requestID: "req_list",
+          envID,
+          tool: "process",
+          action: "list",
+          sessionID: opened.result.metadata.sessionID!,
+          payload: { action: "list" },
+        },
+      })
+      expect(listed.ok).toBe(true)
+      expect(listed.tool).toBe("process")
+      expect(listed.action).toBe("list")
+      expect(listed.result.metadata.action).toBe("list")
+      expect(listed.result.metadata.envID).toBe(envID)
+      expect(listed.result.metadata.backend).toBe("remote")
     } finally {
       await runtime.control.stop()
     }

package/test/holos-auth.test.ts

@@ -0,0 +1,117 @@
+import { afterEach, describe, expect, test } from "bun:test"
+import { access, mkdtemp, mkdir, readFile, writeFile } from "node:fs/promises"
+import os from "node:os"
+import path from "node:path"
+import process from "node:process"
+import { MetaSynergyHolosAuth } from "../src/holos/auth"
+import { MetaSynergyStore } from "../src/state/store"
+
+async function createTempRoot() {
+  return await mkdtemp(path.join(os.tmpdir(), "meta-synergy-auth-test-"))
+}
+
+describe("meta-synergy holos auth", () => {
+  let originalMetaHome: string | undefined
+  let originalSynergyHome: string | undefined
+
+  afterEach(() => {
+    if (originalMetaHome === undefined) delete process.env.META_SYNERGY_HOME
+    else process.env.META_SYNERGY_HOME = originalMetaHome
+
+    if (originalSynergyHome === undefined) delete process.env.SYNERGY_TEST_HOME
+    else process.env.SYNERGY_TEST_HOME = originalSynergyHome
+  })
+
+  test("loads shared synergy holos credentials", async () => {
+    originalMetaHome = process.env.META_SYNERGY_HOME
+    originalSynergyHome = process.env.SYNERGY_TEST_HOME
+
+    const metaRoot = await createTempRoot()
+    const synergyHome = await createTempRoot()
+    process.env.META_SYNERGY_HOME = metaRoot
+    process.env.SYNERGY_TEST_HOME = synergyHome
+
+    const sharedPath = MetaSynergyHolosAuth.sharedAuthPath()
+    await mkdir(path.dirname(sharedPath), { recursive: true })
+    await writeFile(
+      sharedPath,
+      JSON.stringify({ holos: { type: "holos", agentId: "agent_shared", agentSecret: "secret_shared" } }, null, 2),
+    )
+
+    await expect(MetaSynergyHolosAuth.inspect()).resolves.toEqual({
+      auth: {
+        agentID: "agent_shared",
+        agentSecret: "secret_shared",
+      },
+      source: "shared",
+    })
+  })
+
+  test("falls back to legacy auth and migrates it to shared store", async () => {
+    originalMetaHome = process.env.META_SYNERGY_HOME
+    originalSynergyHome = process.env.SYNERGY_TEST_HOME
+
+    const metaRoot = await createTempRoot()
+    const synergyHome = await createTempRoot()
+    process.env.META_SYNERGY_HOME = metaRoot
+    process.env.SYNERGY_TEST_HOME = synergyHome
+
+    await MetaSynergyStore.saveLegacyAuth({ agentID: "agent_legacy", agentSecret: "secret_legacy" })
+
+    await expect(MetaSynergyHolosAuth.inspect()).resolves.toEqual({
+      auth: {
+        agentID: "agent_legacy",
+        agentSecret: "secret_legacy",
+      },
+      source: "legacy-migrated",
+    })
+
+    const sharedPath = MetaSynergyHolosAuth.sharedAuthPath()
+    const shared = JSON.parse(await readFile(sharedPath, "utf8")) as {
+      holos: { type: string; agentId: string; agentSecret: string }
+    }
+
+    expect(shared.holos).toEqual({
+      type: "holos",
+      agentId: "agent_legacy",
+      agentSecret: "secret_legacy",
+    })
+  })
+
+  test("clear removes holos credentials from shared and legacy stores", async () => {
+    originalMetaHome = process.env.META_SYNERGY_HOME
+    originalSynergyHome = process.env.SYNERGY_TEST_HOME
+
+    const metaRoot = await createTempRoot()
+    const synergyHome = await createTempRoot()
+    process.env.META_SYNERGY_HOME = metaRoot
+    process.env.SYNERGY_TEST_HOME = synergyHome
+
+    await MetaSynergyStore.saveLegacyAuth({ agentID: "agent_clear", agentSecret: "secret_clear" })
+
+    const sharedPath = MetaSynergyHolosAuth.sharedAuthPath()
+    await mkdir(path.dirname(sharedPath), { recursive: true })
+    await writeFile(
+      sharedPath,
+      JSON.stringify(
+        {
+          another: { type: "token", value: "keep-me" },
+          holos: { type: "holos", agentId: "agent_clear", agentSecret: "secret_clear" },
+        },
+        null,
+        2,
+      ),
+    )
+
+    await MetaSynergyHolosAuth.clear()
+
+    await expect(MetaSynergyHolosAuth.inspect()).resolves.toEqual({
+      auth: undefined,
+      source: null,
+    })
+
+    await expect(access(MetaSynergyStore.legacyAuthPath())).rejects.toThrow()
+    await expect(readFile(sharedPath, "utf8")).resolves.toContain('"another"')
+    await expect(readFile(sharedPath, "utf8")).resolves.not.toContain('"holos"')
+  })
+})

package/test/migration.test.ts

@@ -0,0 +1,58 @@
+import { afterEach, describe, expect, test } from "bun:test"
+import { mkdtemp, readFile, writeFile } from "node:fs/promises"
+import os from "node:os"
+import path from "node:path"
+import process from "node:process"
+import { MetaSynergyMigrationRunner } from "../src/migration"
+import { MetaSynergyStore } from "../src/state/store"
+
+async function createTempRoot() {
+  return await mkdtemp(path.join(os.tmpdir(), "meta-synergy-migration-test-"))
+}
+
+describe("meta-synergy migration runner", () => {
+  let originalMetaHome: string | undefined
+
+  afterEach(() => {
+    if (originalMetaHome === undefined) delete process.env.META_SYNERGY_HOME
+    else process.env.META_SYNERGY_HOME = originalMetaHome
+  })
+
+  test("normalizes persisted state and records migration", async () => {
+    originalMetaHome = process.env.META_SYNERGY_HOME
+    const root = await createTempRoot()
+    process.env.META_SYNERGY_HOME = root
+
+    await writeFile(
+      MetaSynergyStore.statePath(),
+      JSON.stringify({
+        collaborationEnabled: true,
+        approvalMode: "invalid",
+        trusted: { agentIDs: ["a", "a"], ownerUserIDs: [1, 1] },
+        pendingRequests: [{ id: "r1", callerAgentID: "agent", callerOwnerUserID: 7, requestedAt: 1, status: "weird" }],
+        blockedAgentIDs: ["b", "b"],
+        connectionStatus: "mystery",
+        service: { desiredState: "maybe", runtimeStatus: "wat", pid: "oops", printLogs: true },
+        logs: { filePath: "" },
+      }),
+    )
+
+    await MetaSynergyMigrationRunner.run()
+
+    const state = await MetaSynergyStore.loadState()
+    expect(state.runtimeMode).toBe("standalone")
+    expect(state.ownerRegistry.local.ownerIDs).toEqual([])
+    expect(state.approvalMode).toBe("manual")
+    expect(state.blockedAgentIDs).toEqual(["b"])
+    expect(state.trusted.agentIDs).toEqual(["a"])
+    expect(state.trusted.ownerUserIDs).toEqual([1])
+    expect(state.connectionStatus).toBe("disconnected")
+    expect(state.service.desiredState).toBe("stopped")
+    expect(state.service.runtimeStatus).toBe("stopped")
+    expect(state.service.pid).toBeUndefined()
+    expect(state.pendingRequests[0]?.status).toBe("pending")
+
+    const log = JSON.parse(await readFile(MetaSynergyStore.migrationLogPath(), "utf8")) as Record<string, number>
+    expect(typeof log["20260408-normalize-state"]).toBe("number")
+  })
+})

package/test/runtime-managed-mode.test.ts

@@ -0,0 +1,111 @@
+import { afterAll, beforeEach, describe, expect, test } from "bun:test"
+import { mkdtemp, rm, writeFile } from "node:fs/promises"
+import os from "node:os"
+import path from "node:path"
+import process from "node:process"
+import { MetaSynergyRuntime } from "../src/runtime"
+import { MetaSynergyStore } from "../src/state/store"
+
+const originalHome = process.env.META_SYNERGY_HOME
+const tempRoots: string[] = []
+
+beforeEach(async () => {
+  const root = await mkdtemp(path.join(os.tmpdir(), "meta-synergy-managed-test-"))
+  tempRoots.push(root)
+  process.env.META_SYNERGY_HOME = root
+})
+
+afterAll(async () => {
+  if (originalHome === undefined) {
+    delete process.env.META_SYNERGY_HOME
+  } else {
+    process.env.META_SYNERGY_HOME = originalHome
+  }
+  await Promise.all(tempRoots.map((root) => rm(root, { recursive: true, force: true })))
+})
+
+describe("meta-synergy managed mode", () => {
+  test("startup stays healthy without Holos auth or websocket", async () => {
+    const state = await MetaSynergyStore.loadState()
+    state.runtimeMode = "managed"
+    state.ownerRegistry.local.activeOwnerID = "synergy:test"
+    state.ownerRegistry.local.ownerIDs = ["synergy:test"]
+    state.ownerRegistry.local.leaseExpiresAt = Date.now() + 60_000
+    await MetaSynergyStore.saveState(state)
+    await writeFile(
+      MetaSynergyStore.ownerRegistryPath(),
+      JSON.stringify(
+        {
+          local: {
+            ownerIDs: ["synergy:test"],
+            activeOwnerID: "synergy:test",
+            leaseExpiresAt: Date.now() + 60_000,
+          },
+        },
+        null,
+        2,
+      ) + "\n",
+    )
+
+    const runtime = await MetaSynergyRuntime.create()
+    const originalLogin = runtime.login.bind(runtime)
+    let loginCalled = false
+    runtime.login = async () => {
+      loginCalled = true
+      return await originalLogin()
+    }
+
+    const startPromise = runtime.start()
+    await new Promise((resolve) => setTimeout(resolve, 200))
+
+    expect(loginCalled).toBe(false)
+    expect(runtime.state?.runtimeMode).toBe("managed")
+    expect(runtime.state?.connectionStatus).toBe("disconnected")
+    expect(runtime.state?.service.runtimeStatus).toBe("running")
+    expect(runtime.state?.ownerRegistry.local.activeOwnerID).toBe("synergy:test")
+
+    const status = await runtime.getStatusPayload()
+    expect(status.mode).toBe("managed")
+    expect(status.auth.loggedIn).toBe(true)
+    expect(status.auth.source).toBe("shared")
+    expect(status.auth.hiddenReason).toBe("managed")
+    expect(status.ownership.local.owned).toBe(true)
+
+    const reconnect = await runtime.reconnect()
+    expect(reconnect.requested).toBe(false)
+    expect(reconnect.reason).toBe("Holos is disabled in managed mode")
+
+    await runtime.stopServerProcess()
+    await Promise.race([
+      startPromise,
+      new Promise((_, reject) => setTimeout(() => reject(new Error("runtime.start did not settle after stop")), 2_000)),
+    ])
+  })
+
+  test("startup recovers managed state without an active owner back to standalone", async () => {
+    const state = await MetaSynergyStore.loadState()
+    state.runtimeMode = "managed"
+    state.ownerRegistry.local.activeOwnerID = undefined
+    state.ownerRegistry.local.ownerIDs = []
+    state.ownerRegistry.local.leaseExpiresAt = undefined
+    await MetaSynergyStore.saveState(state)
+    await writeFile(
+      MetaSynergyStore.ownerRegistryPath(),
+      JSON.stringify(
+        {
+          local: {
+            ownerIDs: [],
+            activeOwnerID: null,
+            leaseExpiresAt: null,
+          },
+        },
+        null,
+        2,
+      ) + "\n",
+    )
+
+    const runtime = await MetaSynergyRuntime.create()
+    expect(runtime.state?.runtimeMode).toBe("standalone")
+    expect(runtime.state?.ownerRegistry.local.activeOwnerID).toBeUndefined()
+  })
+})

package/script/publish.ts

@@ -1,38 +0,0 @@
-#!/usr/bin/env bun
-import { Script } from "@ericsanchezok/synergy-script"
-import { $ } from "bun"
-
-const dir = new URL("..", import.meta.url).pathname
-process.chdir(dir)
-
-await $`bun tsc`
-const pkg = await import("../package.json").then((m) => m.default)
-const original = JSON.parse(JSON.stringify(pkg))
-for (const [key, value] of Object.entries(pkg.exports)) {
-  const source = typeof value === "string" ? value : (value as { import?: string }).import
-  if (!source || typeof source !== "string") continue
-  const file = source.replace("./src/", "./dist/").replace(".ts", "").replace(".js", "")
-  // @ts-ignore
-  pkg.exports[key] = {
-    import: file + ".js",
-    types: file + ".d.ts",
-  }
-}
-await Bun.write("package.json", JSON.stringify(pkg, null, 2))
-
-try {
-  if (await Script.npmVersionExists(pkg.name, Script.version)) {
-    console.log(`${pkg.name}@${Script.version} already published, skipping`)
-  } else {
-    const NPM_REGISTRY = "https://registry.npmjs.org"
-    await $`rm -f *.tgz`.nothrow()
-    await $`bun pm pack`
-    const tgz = (await $`ls *.tgz`.text()).trim()
-    const authFlag = process.env.NPM_TOKEN ? `--//registry.npmjs.org/:_authToken=${process.env.NPM_TOKEN}` : ""
-    await Script.retry(
-      () => $`npm publish ${tgz} --tag ${Script.channel} --registry ${NPM_REGISTRY} --access public ${authFlag}`,
-    )
-  }
-} finally {
-  await Bun.write("package.json", JSON.stringify(original, null, 2))
-}